From 490daa8a8c865fe6414ce4037b5d3ba4dc533ff5 Mon Sep 17 00:00:00 2001 From: Mitchell Hanberg Date: Wed, 1 Jan 2025 12:00:28 -0500 Subject: [PATCH 01/12] wip: copy remote control app --- engine/lib/engine.ex | 230 +++++++- engine/lib/engine/analyzer.ex | 213 +++++++ engine/lib/engine/analyzer/aliases.ex | 62 ++ engine/lib/engine/analyzer/imports.ex | 144 +++++ engine/lib/engine/analyzer/requires.ex | 26 + engine/lib/engine/analyzer/uses.ex | 23 + engine/lib/engine/api.ex | 136 +++++ engine/lib/engine/api/messages.ex | 139 +++++ engine/lib/engine/api/proxy.ex | 247 ++++++++ .../lib/engine/api/proxy/buffering_state.ex | 146 +++++ engine/lib/engine/api/proxy/draining_state.ex | 30 + engine/lib/engine/api/proxy/proxying_state.ex | 42 ++ engine/lib/engine/api/proxy/records.ex | 37 ++ engine/lib/engine/application.ex | 36 +- engine/lib/engine/bootstrap.ex | 128 +++++ engine/lib/engine/build.ex | 102 ++++ engine/lib/engine/build/capture_io.ex | 103 ++++ engine/lib/engine/build/capture_server.ex | 197 +++++++ engine/lib/engine/build/document.ex | 23 + engine/lib/engine/build/document/compiler.ex | 26 + .../engine/build/document/compilers/config.ex | 119 ++++ .../engine/build/document/compilers/eex.ex | 133 +++++ .../engine/build/document/compilers/elixir.ex | 43 ++ .../engine/build/document/compilers/heex.ex | 84 +++ .../engine/build/document/compilers/no_op.ex | 14 + .../engine/build/document/compilers/quoted.ex | 282 +++++++++ engine/lib/engine/build/error.ex | 354 ++++++++++++ engine/lib/engine/build/error/location.ex | 97 ++++ engine/lib/engine/build/error/parse.ex | 198 +++++++ engine/lib/engine/build/isolation.ex | 25 + engine/lib/engine/build/project.ex | 128 +++++ engine/lib/engine/build/state.ex | 261 +++++++++ engine/lib/engine/code_action.ex | 62 ++ engine/lib/engine/code_action/diagnostic.ex | 17 + engine/lib/engine/code_action/handler.ex | 9 + .../engine/code_action/handlers/add_alias.ex | 211 +++++++ .../code_action/handlers/organize_aliases.ex | 45 ++ .../handlers/remove_unused_alias.ex | 245 ++++++++ .../handlers/replace_remote_function.ex | 146 +++++ .../handlers/replace_with_underscore.ex | 83 +++ .../engine/code_intelligence/definition.ex | 183 ++++++ engine/lib/engine/code_intelligence/docs.ex | 96 ++++ .../engine/code_intelligence/docs/entry.ex | 56 ++ engine/lib/engine/code_intelligence/entity.ex | 539 ++++++++++++++++++ .../engine/code_intelligence/references.ex | 100 ++++ .../lib/engine/code_intelligence/structs.ex | 27 + .../lib/engine/code_intelligence/symbols.ex | 125 ++++ .../code_intelligence/symbols/document.ex | 99 ++++ .../code_intelligence/symbols/workspace.ex | 55 ++ .../lib/engine/code_intelligence/variable.ex | 249 ++++++++ engine/lib/engine/code_mod/aliases.ex | 256 +++++++++ engine/lib/engine/code_mod/diff.ex | 121 ++++ engine/lib/engine/code_mod/format.ex | 238 ++++++++ engine/lib/engine/commands/reindex.ex | 166 ++++++ engine/lib/engine/compilation/tracer.ex | 81 +++ engine/lib/engine/completion.ex | 139 +++++ engine/lib/engine/completion/candidate.ex | 302 ++++++++++ .../completion/candidate/argument_names.ex | 120 ++++ engine/lib/engine/dispatch.ex | 84 +++ engine/lib/engine/dispatch/handler.ex | 105 ++++ .../lib/engine/dispatch/handlers/indexing.ex | 36 ++ engine/lib/engine/dispatch/pub_sub.ex | 120 ++++ engine/lib/engine/document_symbols.ex | 237 -------- engine/lib/engine/mix.ex | 54 ++ .../lib/engine/mix.tasks.deps.safe_compile.ex | 381 +++++++++++++ engine/lib/engine/module/loader.ex | 43 ++ engine/lib/engine/module_mappings.ex | 85 +++ engine/lib/engine/modules.ex | 255 +++++++++ engine/lib/engine/plugin.ex | 48 ++ engine/lib/engine/plugin/discovery.ex | 73 +++ engine/lib/engine/plugin/runner.ex | 118 ++++ .../lib/engine/plugin/runner/coordinator.ex | 35 ++ .../engine/plugin/runner/coordinator/state.ex | 102 ++++ engine/lib/engine/plugin/supervisor.ex | 20 + engine/lib/engine/port.ex | 87 +++ engine/lib/engine/progress.ex | 68 +++ engine/lib/engine/project_node.ex | 244 ++++++++ engine/lib/engine/project_node_supervisor.ex | 27 + engine/lib/engine/search/fuzzy.ex | 386 +++++++++++++ engine/lib/engine/search/fuzzy/scorer.ex | 310 ++++++++++ engine/lib/engine/search/indexer.ex | 211 +++++++ engine/lib/engine/search/indexer/entry.ex | 155 +++++ .../search/indexer/extractors/ecto_schema.ex | 112 ++++ .../search/indexer/extractors/ex_unit.ex | 128 +++++ .../indexer/extractors/function_definition.ex | 110 ++++ .../indexer/extractors/function_reference.ex | 276 +++++++++ .../search/indexer/extractors/module.ex | 344 +++++++++++ .../indexer/extractors/module_attribute.ex | 107 ++++ .../indexer/extractors/struct_definition.ex | 35 ++ .../indexer/extractors/struct_reference.ex | 93 +++ .../search/indexer/extractors/variable.ex | 249 ++++++++ engine/lib/engine/search/indexer/metadata.ex | 74 +++ engine/lib/engine/search/indexer/module.ex | 27 + engine/lib/engine/search/indexer/quoted.ex | 29 + engine/lib/engine/search/indexer/source.ex | 19 + .../lib/engine/search/indexer/source/block.ex | 17 + .../engine/search/indexer/source/reducer.ex | 187 ++++++ engine/lib/engine/search/store.ex | 294 ++++++++++ engine/lib/engine/search/store/backend.ex | 109 ++++ .../lib/engine/search/store/backends/ets.ex | 246 ++++++++ .../search/store/backends/ets/schema.ex | 229 ++++++++ .../store/backends/ets/schemas/legacy_v0.ex | 19 + .../search/store/backends/ets/schemas/v1.ex | 79 +++ .../search/store/backends/ets/schemas/v2.ex | 69 +++ .../search/store/backends/ets/schemas/v3.ex | 82 +++ .../engine/search/store/backends/ets/state.ex | 297 ++++++++++ .../engine/search/store/backends/ets/wal.ex | 423 ++++++++++++++ engine/lib/engine/search/store/state.ex | 260 +++++++++ engine/lib/engine/search/subject.ex | 18 + engine/lib/engine/worker.ex | 64 --- 110 files changed, 14565 insertions(+), 313 deletions(-) create mode 100644 engine/lib/engine/analyzer.ex create mode 100644 engine/lib/engine/analyzer/aliases.ex create mode 100644 engine/lib/engine/analyzer/imports.ex create mode 100644 engine/lib/engine/analyzer/requires.ex create mode 100644 engine/lib/engine/analyzer/uses.ex create mode 100644 engine/lib/engine/api.ex create mode 100644 engine/lib/engine/api/messages.ex create mode 100644 engine/lib/engine/api/proxy.ex create mode 100644 engine/lib/engine/api/proxy/buffering_state.ex create mode 100644 engine/lib/engine/api/proxy/draining_state.ex create mode 100644 engine/lib/engine/api/proxy/proxying_state.ex create mode 100644 engine/lib/engine/api/proxy/records.ex create mode 100644 engine/lib/engine/bootstrap.ex create mode 100644 engine/lib/engine/build.ex create mode 100644 engine/lib/engine/build/capture_io.ex create mode 100644 engine/lib/engine/build/capture_server.ex create mode 100644 engine/lib/engine/build/document.ex create mode 100644 engine/lib/engine/build/document/compiler.ex create mode 100644 engine/lib/engine/build/document/compilers/config.ex create mode 100644 engine/lib/engine/build/document/compilers/eex.ex create mode 100644 engine/lib/engine/build/document/compilers/elixir.ex create mode 100644 engine/lib/engine/build/document/compilers/heex.ex create mode 100644 engine/lib/engine/build/document/compilers/no_op.ex create mode 100644 engine/lib/engine/build/document/compilers/quoted.ex create mode 100644 engine/lib/engine/build/error.ex create mode 100644 engine/lib/engine/build/error/location.ex create mode 100644 engine/lib/engine/build/error/parse.ex create mode 100644 engine/lib/engine/build/isolation.ex create mode 100644 engine/lib/engine/build/project.ex create mode 100644 engine/lib/engine/build/state.ex create mode 100644 engine/lib/engine/code_action.ex create mode 100644 engine/lib/engine/code_action/diagnostic.ex create mode 100644 engine/lib/engine/code_action/handler.ex create mode 100644 engine/lib/engine/code_action/handlers/add_alias.ex create mode 100644 engine/lib/engine/code_action/handlers/organize_aliases.ex create mode 100644 engine/lib/engine/code_action/handlers/remove_unused_alias.ex create mode 100644 engine/lib/engine/code_action/handlers/replace_remote_function.ex create mode 100644 engine/lib/engine/code_action/handlers/replace_with_underscore.ex create mode 100644 engine/lib/engine/code_intelligence/definition.ex create mode 100644 engine/lib/engine/code_intelligence/docs.ex create mode 100644 engine/lib/engine/code_intelligence/docs/entry.ex create mode 100644 engine/lib/engine/code_intelligence/entity.ex create mode 100644 engine/lib/engine/code_intelligence/references.ex create mode 100644 engine/lib/engine/code_intelligence/structs.ex create mode 100644 engine/lib/engine/code_intelligence/symbols.ex create mode 100644 engine/lib/engine/code_intelligence/symbols/document.ex create mode 100644 engine/lib/engine/code_intelligence/symbols/workspace.ex create mode 100644 engine/lib/engine/code_intelligence/variable.ex create mode 100644 engine/lib/engine/code_mod/aliases.ex create mode 100644 engine/lib/engine/code_mod/diff.ex create mode 100644 engine/lib/engine/code_mod/format.ex create mode 100644 engine/lib/engine/commands/reindex.ex create mode 100644 engine/lib/engine/compilation/tracer.ex create mode 100644 engine/lib/engine/completion.ex create mode 100644 engine/lib/engine/completion/candidate.ex create mode 100644 engine/lib/engine/completion/candidate/argument_names.ex create mode 100644 engine/lib/engine/dispatch.ex create mode 100644 engine/lib/engine/dispatch/handler.ex create mode 100644 engine/lib/engine/dispatch/handlers/indexing.ex create mode 100644 engine/lib/engine/dispatch/pub_sub.ex delete mode 100644 engine/lib/engine/document_symbols.ex create mode 100644 engine/lib/engine/mix.ex create mode 100644 engine/lib/engine/mix.tasks.deps.safe_compile.ex create mode 100644 engine/lib/engine/module/loader.ex create mode 100644 engine/lib/engine/module_mappings.ex create mode 100644 engine/lib/engine/modules.ex create mode 100644 engine/lib/engine/plugin.ex create mode 100644 engine/lib/engine/plugin/discovery.ex create mode 100644 engine/lib/engine/plugin/runner.ex create mode 100644 engine/lib/engine/plugin/runner/coordinator.ex create mode 100644 engine/lib/engine/plugin/runner/coordinator/state.ex create mode 100644 engine/lib/engine/plugin/supervisor.ex create mode 100644 engine/lib/engine/port.ex create mode 100644 engine/lib/engine/progress.ex create mode 100644 engine/lib/engine/project_node.ex create mode 100644 engine/lib/engine/project_node_supervisor.ex create mode 100644 engine/lib/engine/search/fuzzy.ex create mode 100644 engine/lib/engine/search/fuzzy/scorer.ex create mode 100644 engine/lib/engine/search/indexer.ex create mode 100644 engine/lib/engine/search/indexer/entry.ex create mode 100644 engine/lib/engine/search/indexer/extractors/ecto_schema.ex create mode 100644 engine/lib/engine/search/indexer/extractors/ex_unit.ex create mode 100644 engine/lib/engine/search/indexer/extractors/function_definition.ex create mode 100644 engine/lib/engine/search/indexer/extractors/function_reference.ex create mode 100644 engine/lib/engine/search/indexer/extractors/module.ex create mode 100644 engine/lib/engine/search/indexer/extractors/module_attribute.ex create mode 100644 engine/lib/engine/search/indexer/extractors/struct_definition.ex create mode 100644 engine/lib/engine/search/indexer/extractors/struct_reference.ex create mode 100644 engine/lib/engine/search/indexer/extractors/variable.ex create mode 100644 engine/lib/engine/search/indexer/metadata.ex create mode 100644 engine/lib/engine/search/indexer/module.ex create mode 100644 engine/lib/engine/search/indexer/quoted.ex create mode 100644 engine/lib/engine/search/indexer/source.ex create mode 100644 engine/lib/engine/search/indexer/source/block.ex create mode 100644 engine/lib/engine/search/indexer/source/reducer.ex create mode 100644 engine/lib/engine/search/store.ex create mode 100644 engine/lib/engine/search/store/backend.ex create mode 100644 engine/lib/engine/search/store/backends/ets.ex create mode 100644 engine/lib/engine/search/store/backends/ets/schema.ex create mode 100644 engine/lib/engine/search/store/backends/ets/schemas/legacy_v0.ex create mode 100644 engine/lib/engine/search/store/backends/ets/schemas/v1.ex create mode 100644 engine/lib/engine/search/store/backends/ets/schemas/v2.ex create mode 100644 engine/lib/engine/search/store/backends/ets/schemas/v3.ex create mode 100644 engine/lib/engine/search/store/backends/ets/state.ex create mode 100644 engine/lib/engine/search/store/backends/ets/wal.ex create mode 100644 engine/lib/engine/search/store/state.ex create mode 100644 engine/lib/engine/search/subject.ex delete mode 100644 engine/lib/engine/worker.ex diff --git a/engine/lib/engine.ex b/engine/lib/engine.ex index a0a11aed..392a8a93 100644 --- a/engine/lib/engine.ex +++ b/engine/lib/engine.ex @@ -1,5 +1,229 @@ -defmodule Engine do - def ensure_all_started() do - Application.ensure_all_started(:engine) +defmodule Lexical.RemoteControl do + @moduledoc """ + The remote control boots another elixir application in a separate VM, injects + the remote control application into it and allows the language server to execute tasks in the + context of the remote VM. + """ + + alias Lexical.Project + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Api.Proxy + alias Lexical.RemoteControl.CodeAction + alias Lexical.RemoteControl.CodeIntelligence + alias Lexical.RemoteControl.ProjectNode + + require Logger + + @excluded_apps [:patch, :nimble_parsec] + @allowed_apps [:remote_control | Mix.Project.deps_apps()] -- @excluded_apps + + defdelegate schedule_compile(force?), to: Proxy + + defdelegate compile_document(document), to: Proxy + + defdelegate format(document), to: Proxy + + defdelegate reindex, to: Proxy + + defdelegate index_running?, to: Proxy + + defdelegate broadcast(message), to: Proxy + + defdelegate expand_alias(segments_or_module, analysis, position), to: RemoteControl.Analyzer + + defdelegate list_modules, to: :code, as: :all_available + + defdelegate code_actions(document, range, diagnostics, kinds), to: CodeAction, as: :for_range + + defdelegate complete(env), to: RemoteControl.Completion, as: :elixir_sense_expand + + defdelegate complete_struct_fields(analysis, position), + to: RemoteControl.Completion, + as: :struct_fields + + defdelegate definition(document, position), to: CodeIntelligence.Definition + + defdelegate references(analysis, position, include_definitions?), + to: CodeIntelligence.References + + defdelegate modules_with_prefix(prefix), to: RemoteControl.Modules, as: :with_prefix + + defdelegate modules_with_prefix(prefix, predicate), to: RemoteControl.Modules, as: :with_prefix + + defdelegate docs(module, opts \\ []), to: CodeIntelligence.Docs, as: :for_module + + defdelegate register_listener(listener_pid, message_types), to: RemoteControl.Dispatch + + defdelegate resolve_entity(analysis, position), to: CodeIntelligence.Entity, as: :resolve + + defdelegate struct_definitions, to: CodeIntelligence.Structs, as: :for_project + + defdelegate document_symbols(document), to: CodeIntelligence.Symbols, as: :for_document + + defdelegate workspace_symbols(query), to: CodeIntelligence.Symbols, as: :for_workspace + + def start_link(%Project{} = project) do + :ok = ensure_epmd_started() + start_net_kernel(project) + + apps_to_start = [:elixir | @allowed_apps] ++ [:runtime_tools] + node = Project.node_name(project) + + with {:ok, node_pid} <- ProjectNode.start(project, glob_paths()), + :ok <- ensure_apps_started(node, apps_to_start) do + {:ok, node, node_pid} + end + end + + def with_lock(lock_type, func) do + :global.trans({lock_type, self()}, func, [Node.self()]) + end + + def project_node? do + !!:persistent_term.get({__MODULE__, :project}, false) + end + + def get_project do + :persistent_term.get({__MODULE__, :project}, nil) + end + + def set_project(%Project{} = project) do + :persistent_term.put({__MODULE__, :project}, project) + end + + defdelegate stop(project), to: ProjectNode + + def call(%Project{} = project, m, f, a \\ []) do + project + |> Project.node_name() + |> :erpc.call(m, f, a) + end + + def manager_node_name(%Project{} = project) do + :"manager-#{Project.name(project)}-#{Project.entropy(project)}@127.0.0.1" + end + + defp start_net_kernel(%Project{} = project) do + manager = manager_node_name(project) + :net_kernel.start(manager, %{name_domain: :longnames}) + end + + defp ensure_apps_started(node, app_names) do + Enum.reduce_while(app_names, :ok, fn app_name, _ -> + case :rpc.call(node, :application, :ensure_all_started, [app_name]) do + {:ok, _} -> {:cont, :ok} + error -> {:halt, error} + end + end) + end + + defp glob_paths do + for entry <- :code.get_path(), + entry_string = List.to_string(entry), + entry_string != ".", + Enum.any?(app_globs(), &PathGlob.match?(entry_string, &1, match_dot: true)) do + entry + end + end + + def elixir_executable(%Project{} = project) do + root_path = Project.root_path(project) + + {path_result, env} = + with nil <- version_manager_path_and_env("asdf", root_path), + nil <- version_manager_path_and_env("mise", root_path), + nil <- version_manager_path_and_env("rtx", root_path) do + {File.cd!(root_path, fn -> System.find_executable("elixir") end), System.get_env()} + end + + case path_result do + nil -> + {:error, :no_elixir} + + executable when is_binary(executable) -> + {:ok, executable, env} + end + end + + defp app_globs do + app_globs = Enum.map(@allowed_apps, fn app_name -> "/**/#{app_name}*/ebin" end) + ["/**/priv" | app_globs] + end + + defp ensure_epmd_started do + case System.cmd("epmd", ~w(-daemon)) do + {"", 0} -> + :ok + + _ -> + {:error, :epmd_failed} + end + end + + defp version_manager_path_and_env(manager, root_path) do + with true <- is_binary(System.find_executable(manager)), + env = reset_env(manager, root_path), + {path, 0} <- System.cmd(manager, ~w(which elixir), cd: root_path, env: env) do + {String.trim(path), env} + else + _ -> + nil + end + end + + # We launch lexical by asking the version managers to provide an environment, + # which contains path munging. This initial environment is present in the running + # VM, and needs to be undone so we can find the correct elixir executable in the project. + defp reset_env("asdf", _root_path) do + orig_path = System.get_env("PATH_SAVE", System.get_env("PATH")) + + Enum.map(System.get_env(), fn + {"ASDF_ELIXIR_VERSION", _} -> {"ASDF_ELIXIR_VERSION", nil} + {"ASDF_ERLANG_VERSION", _} -> {"ASDF_ERLANG_VERSION", nil} + {"PATH", _} -> {"PATH", orig_path} + other -> other + end) + end + + defp reset_env("rtx", root_path) do + {env, _} = System.cmd("rtx", ~w(env -s bash), cd: root_path) + + env + |> String.trim() + |> String.split("\n") + |> Enum.map(fn + "export " <> key_and_value -> + [key, value] = + key_and_value + |> String.split("=", parts: 2) + |> Enum.map(&String.trim/1) + + {key, value} + + _ -> + nil + end) + |> Enum.reject(&is_nil/1) + end + + defp reset_env("mise", root_path) do + {env, _} = System.cmd("mise", ~w(env -s bash), cd: root_path) + + env + |> String.trim() + |> String.split("\n") + |> Enum.map(fn + "export " <> key_and_value -> + [key, value] = + key_and_value + |> String.split("=", parts: 2) + |> Enum.map(&String.trim/1) + + {key, value} + + _ -> + nil + end) + |> Enum.reject(&is_nil/1) end end diff --git a/engine/lib/engine/analyzer.ex b/engine/lib/engine/analyzer.ex new file mode 100644 index 00000000..872c8171 --- /dev/null +++ b/engine/lib/engine/analyzer.ex @@ -0,0 +1,213 @@ +defmodule Lexical.RemoteControl.Analyzer do + alias Lexical.Ast + alias Lexical.Ast.Analysis + alias Lexical.Ast.Analysis.Require + alias Lexical.Ast.Analysis.Use + alias Lexical.Document.Position + alias Lexical.RemoteControl.Analyzer.Aliases + alias Lexical.RemoteControl.Analyzer.Imports + alias Lexical.RemoteControl.Analyzer.Requires + alias Lexical.RemoteControl.Analyzer.Uses + + require Logger + + defdelegate aliases_at(analysis, position), to: Aliases, as: :at + defdelegate imports_at(analysis, position), to: Imports, as: :at + + @spec requires_at(Analysis.t(), Position.t()) :: [module()] + def requires_at(%Analysis{} = analysis, %Position{} = position) do + analysis + |> Requires.at(position) + |> Enum.reduce([], fn %Require{} = require, acc -> + case expand_alias(require.module, analysis, position) do + {:ok, expanded} -> [expanded | acc] + _ -> [Module.concat(require.as) | acc] + end + end) + end + + @spec uses_at(Analysis.t(), Position.t()) :: [module()] + def uses_at(%Analysis{} = analysis, %Position{} = position) do + analysis + |> Uses.at(position) + |> Enum.reduce([], fn %Use{} = use, acc -> + case expand_alias(use.module, analysis, position) do + {:ok, expanded} -> [expanded | acc] + _ -> [Module.concat(use.module) | acc] + end + end) + end + + def resolve_local_call(%Analysis{} = analysis, %Position{} = position, function_name, arity) do + maybe_imported_mfa = + analysis + |> imports_at(position) + |> Enum.find(fn + {_, ^function_name, ^arity} -> true + _ -> false + end) + + if is_nil(maybe_imported_mfa) do + aliases = aliases_at(analysis, position) + current_module = aliases[:__MODULE__] + {current_module, function_name, arity} + else + maybe_imported_mfa + end + end + + @doc """ + Expands an alias at the given position in the context of a document + analysis. + + When we refer to a module, it's usually a short name, often aliased or + in a nested module. This function finds the full name of the module at + a cursor position. + + For example, if we have: + + defmodule Project do + defmodule Issue do + defstruct [:message] + end + + def message(%Issue{|} = issue) do # cursor marked as `|` + end + end + + We could get the expansion for the `Issue` alias at the cursor position + like so: + + iex> Analyzer.expand_alias([:Issue], analysis, position) + {:ok, Project.Issue} + + Another example: + + defmodule Project do + defmodule Issue do + defstruct [:message] + end + end + + defmodule MyModule do + alias Project, as: MyProject + + def message(%MyProject.Issue{|} = issue) do + end + end + + This would yield the same result: + + iex> Analyzer.expand_alias([:MyProject, :Issue], analysis, position) + {:ok, Project.Issue} + + If no aliases are present at the given position, no expansion occurs: + + iex> Analyzer.expand_alias([:Some, :Other, :Module], analysis, position) + {:ok, Some.Other.Module} + + """ + @spec expand_alias( + Ast.alias_segments() | module(), + Analysis.t(), + Position.t() | {Position.line(), Position.character()} + ) :: + {:ok, module()} | :error + def expand_alias([_ | _] = segments, %Analysis{} = analysis, %Position{} = position) do + with %Analysis{valid?: true} = analysis <- Lexical.Ast.reanalyze_to(analysis, position), + aliases <- aliases_at(analysis, position), + {:ok, resolved} <- resolve_alias(segments, aliases) do + {:ok, Module.concat(resolved)} + else + _ -> + case segments do + [:__MODULE__] -> + # we've had a request for the current module, but none was found + # so we've failed. This can happen if we're resolving the current + # module in a script, or inside the defmodule call. + :error + + _ -> + if Enum.all?(segments, &is_atom/1) do + {:ok, Module.concat(segments)} + else + :error + end + end + end + end + + def expand_alias(module, %Analysis{} = analysis, %Position{} = position) + when is_atom(module) and not is_nil(module) do + {:elixir, segments} = Ast.Module.safe_split(module, as: :atoms) + expand_alias(segments, analysis, position) + end + + def expand_alias(empty, _, _) when empty in [nil, []] do + Logger.warning("nothing to expand (expand_alias was passed #{inspect(empty)})") + :error + end + + @doc """ + Returns the current module at the given position in the analysis + """ + def current_module(%Analysis{} = analysis, %Position{} = position) do + expand_alias([:__MODULE__], analysis, position) + end + + defp resolve_alias([{:@, _, [{:protocol, _, _}]} | rest], alias_mapping) do + with {:ok, protocol} <- Map.fetch(alias_mapping, :"@protocol") do + Ast.reify_alias(protocol, rest) + end + end + + defp resolve_alias( + [{:__aliases__, _, [{:@, _, [{:protocol, _, _}]} | _] = protocol}], + alias_mapping + ) do + resolve_alias(protocol, alias_mapping) + end + + defp resolve_alias([{:@, _, [{:for, _, _} | _]} | rest], alias_mapping) do + with {:ok, protocol_for} <- Map.fetch(alias_mapping, :"@for") do + Ast.reify_alias(protocol_for, rest) + end + end + + defp resolve_alias( + [{:__aliases__, _, [{:@, _, [{:for, _, _}]} | _] = protocol_for}], + alias_mapping + ) do + resolve_alias(protocol_for, alias_mapping) + end + + defp resolve_alias([first | _] = segments, aliases_mapping) when is_tuple(first) do + with {:ok, current_module} <- Map.fetch(aliases_mapping, :__MODULE__) do + Ast.reify_alias(current_module, segments) + end + end + + defp resolve_alias([first | _] = segments, aliases_mapping) when is_atom(first) do + with :error <- fetch_leading_alias(segments, aliases_mapping) do + fetch_trailing_alias(segments, aliases_mapping) + end + end + + defp resolve_alias(_, _), do: :error + + defp fetch_leading_alias([first | rest], aliases_mapping) do + with {:ok, resolved} <- Map.fetch(aliases_mapping, first) do + {:ok, [resolved | rest]} + end + end + + defp fetch_trailing_alias(segments, aliases_mapping) do + # Trailing aliases happen when you use the curly syntax to define multiple aliases + # in one go, like Foo.{First, Second.Third, Fourth} + # Our alias mapping will have Third mapped to Foo.Second.Third, so we need to look + # for Third, wheras the leading alias will look for Second in the mappings. + with {:ok, resolved} <- Map.fetch(aliases_mapping, List.last(segments)) do + {:ok, List.wrap(resolved)} + end + end +end diff --git a/engine/lib/engine/analyzer/aliases.ex b/engine/lib/engine/analyzer/aliases.ex new file mode 100644 index 00000000..39987779 --- /dev/null +++ b/engine/lib/engine/analyzer/aliases.ex @@ -0,0 +1,62 @@ +defmodule Lexical.RemoteControl.Analyzer.Aliases do + alias Lexical.Ast.Analysis + alias Lexical.Ast.Analysis.Alias + alias Lexical.Ast.Analysis.Scope + alias Lexical.Document.Position + + @spec at(Analysis.t(), Position.t()) :: %{atom() => module()} + def at(%Analysis{} = analysis, %Position{} = position) do + case Analysis.scopes_at(analysis, position) do + [%Scope{} = scope | _] -> + scope + |> Scope.alias_map(position) + |> Map.new(fn {as, %Alias{} = alias} -> + {as, Alias.to_module(alias)} + end) + + [] -> + %{} + end + end + + @doc """ + Resolves an alias in the context of a line and a scope + (used internally when calculating imports) + """ + def resolve_at(%Scope{} = scope, module, line) do + aliases = Scope.alias_map(scope, line) + + case module do + # unquote(__MODULE__).SubModule + [{:unquote, _, [{:__MODULE__, _, _}]} | suffix] -> + resolve_current_module(aliases, suffix) + + [{:__MODULE__, _, _} | suffix] -> + resolve_current_module(aliases, suffix) + + [prefix | suffix] -> + case aliases do + %{^prefix => _} -> + current_module = resolve_alias(aliases, prefix, suffix) + + Module.concat([current_module | suffix]) + + _ -> + Module.concat(module) + end + end + end + + defp resolve_current_module(aliases, suffix) do + resolve_alias(aliases, :__MODULE__, suffix) + end + + defp resolve_alias(aliases, prefix, suffix) do + current_module = + aliases + |> Map.get(prefix) + |> Alias.to_module() + + Module.concat([current_module | suffix]) + end +end diff --git a/engine/lib/engine/analyzer/imports.ex b/engine/lib/engine/analyzer/imports.ex new file mode 100644 index 00000000..77a1bb00 --- /dev/null +++ b/engine/lib/engine/analyzer/imports.ex @@ -0,0 +1,144 @@ +defmodule Lexical.RemoteControl.Analyzer.Imports do + alias Lexical.Ast.Analysis + alias Lexical.Ast.Analysis.Import + alias Lexical.Ast.Analysis.Scope + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.ProcessCache + alias Lexical.RemoteControl.Analyzer.Aliases + alias Lexical.RemoteControl.Module.Loader + + @spec at(Analysis.t(), Position.t()) :: [Scope.import_mfa()] + def at(%Analysis{} = analysis, %Position{} = position) do + case Analysis.scopes_at(analysis, position) do + [%Scope{} = scope | _] -> + imports(scope, position) + + _ -> + [] + end + end + + @spec imports(Scope.t(), Scope.scope_position()) :: [Scope.import_mfa()] + def imports(%Scope{} = scope, position \\ :end) do + scope + |> import_map(position) + |> Map.values() + |> List.flatten() + end + + defp import_map(%Scope{} = scope, position) do + end_line = Scope.end_line(scope, position) + + (kernel_imports(scope) ++ scope.imports) + # sorting by line ensures that imports on later lines + # override imports on earlier lines + |> Enum.sort_by(& &1.range.start.line) + |> Enum.take_while(&(&1.range.start.line <= end_line)) + |> Enum.reduce(%{}, fn %Import{} = import, current_imports -> + apply_to_scope(import, scope, current_imports) + end) + end + + defp apply_to_scope(%Import{} = import, current_scope, %{} = current_imports) do + import_module = Aliases.resolve_at(current_scope, import.module, import.range.start.line) + + functions = mfas_for(import_module, :functions) + macros = mfas_for(import_module, :macros) + + case import.selector do + :all -> + Map.put(current_imports, import_module, functions ++ macros) + + [only: :functions] -> + Map.put(current_imports, import_module, functions) + + [only: :macros] -> + Map.put(current_imports, import_module, macros) + + [only: :sigils] -> + sigils = mfas_for(import_module, :sigils) + Map.put(current_imports, import_module, sigils) + + [only: functions_to_import] -> + functions_to_import = function_and_arity_to_mfa(import_module, functions_to_import) + Map.put(current_imports, import_module, functions_to_import) + + [except: functions_to_except] -> + # This one is a little tricky. Imports using except have two cases. + # In the first case, if the module hasn't been previously imported, we + # collect all the functions in the current module and remove the ones in the + # except clause. + # If the module has been previously imported, we just remove the functions from + # the except clause from those that have been previously imported. + # See: https://hexdocs.pm/elixir/1.13.0/Kernel.SpecialForms.html#import/2-selector + + functions_to_except = function_and_arity_to_mfa(import_module, functions_to_except) + + if already_imported?(current_imports, import_module) do + Map.update!(current_imports, import_module, fn old_imports -> + old_imports -- functions_to_except + end) + else + to_import = (functions ++ macros) -- functions_to_except + Map.put(current_imports, import_module, to_import) + end + end + end + + defp already_imported?(%{} = current_imports, imported_module) do + case current_imports do + %{^imported_module => [_ | _]} -> true + _ -> false + end + end + + defp function_and_arity_to_mfa(current_module, fa_list) when is_list(fa_list) do + Enum.map(fa_list, fn {function, arity} -> {current_module, function, arity} end) + end + + defp mfas_for(current_module, type) do + if Loader.ensure_loaded?(current_module) do + fa_list = function_and_arities_for_module(current_module, type) + + function_and_arity_to_mfa(current_module, fa_list) + else + [] + end + end + + defp function_and_arities_for_module(module, :sigils) do + ProcessCache.trans({module, :info, :sigils}, fn -> + for {name, arity} <- module.__info__(:functions), + string_name = Atom.to_string(name), + sigil?(string_name, arity) do + {name, arity} + end + end) + end + + defp function_and_arities_for_module(module, type) do + ProcessCache.trans({module, :info, type}, fn -> + type + |> module.__info__() + |> Enum.reject(fn {name, arity} -> + string_name = Atom.to_string(name) + String.starts_with?(string_name, "_") or sigil?(string_name, arity) + end) + end) + end + + defp sigil?(string_name, arity) do + String.starts_with?(string_name, "sigil_") and arity in [1, 2] + end + + defp kernel_imports(%Scope{} = scope) do + start_pos = scope.range.start + range = Range.new(start_pos, start_pos) + + [ + Import.implicit(range, [:Kernel]), + Import.implicit(range, [:Kernel, :SpecialForms]) + ] + end +end diff --git a/engine/lib/engine/analyzer/requires.ex b/engine/lib/engine/analyzer/requires.ex new file mode 100644 index 00000000..2faebdf7 --- /dev/null +++ b/engine/lib/engine/analyzer/requires.ex @@ -0,0 +1,26 @@ +defmodule Lexical.RemoteControl.Analyzer.Requires do + alias Lexical.Ast.Analysis + alias Lexical.Ast.Analysis.Require + alias Lexical.Ast.Analysis.Scope + alias Lexical.Document.Position + + def at(%Analysis{} = analysis, %Position{} = position) do + case Analysis.scopes_at(analysis, position) do + [%Scope{} = scope | _] -> + scope.requires + |> Enum.filter(fn %Require{} = require -> + require_end = require.range.end + + if require_end.line == position.line do + require_end.character <= position.character + else + require_end.line < position.line + end + end) + |> Enum.uniq_by(& &1.as) + + _ -> + [] + end + end +end diff --git a/engine/lib/engine/analyzer/uses.ex b/engine/lib/engine/analyzer/uses.ex new file mode 100644 index 00000000..c0921e65 --- /dev/null +++ b/engine/lib/engine/analyzer/uses.ex @@ -0,0 +1,23 @@ +defmodule Lexical.RemoteControl.Analyzer.Uses do + alias Lexical.Ast.Analysis + alias Lexical.Ast.Analysis.Scope + alias Lexical.Document.Position + + def at(%Analysis{} = analysis, %Position{} = position) do + case Analysis.scopes_at(analysis, position) do + [%Scope{} = scope | _] -> + Enum.filter(scope.uses, fn use -> + use_end = use.range.end + + if position.line == use_end.line do + position.character >= use_end.character + else + position.line > use_end.line + end + end) + + _ -> + [] + end + end +end diff --git a/engine/lib/engine/api.ex b/engine/lib/engine/api.ex new file mode 100644 index 00000000..ffb72318 --- /dev/null +++ b/engine/lib/engine/api.ex @@ -0,0 +1,136 @@ +defmodule Lexical.RemoteControl.Api do + alias Lexical.Ast.Analysis + alias Lexical.Ast.Env + alias Lexical.Document + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.Project + alias Lexical.RemoteControl + alias Lexical.RemoteControl.CodeIntelligence + + require Logger + + def schedule_compile(%Project{} = project, force?) do + RemoteControl.call(project, RemoteControl, :schedule_compile, [force?]) + end + + def compile_document(%Project{} = project, %Document{} = document) do + RemoteControl.call(project, RemoteControl, :compile_document, [document]) + end + + def expand_alias( + %Project{} = project, + segments_or_module, + %Analysis{} = analysis, + %Position{} = position + ) do + RemoteControl.call(project, RemoteControl, :expand_alias, [ + segments_or_module, + analysis, + position + ]) + end + + def list_modules(%Project{} = project) do + RemoteControl.call(project, RemoteControl, :list_modules) + end + + def format(%Project{} = project, %Document{} = document) do + RemoteControl.call(project, RemoteControl, :format, [document]) + end + + def code_actions( + %Project{} = project, + %Document{} = document, + %Range{} = range, + diagnostics, + kinds + ) do + RemoteControl.call(project, RemoteControl, :code_actions, [ + document, + range, + diagnostics, + kinds + ]) + end + + def complete(%Project{} = project, %Env{} = env) do + Logger.info("Completion for #{inspect(env.position)}") + RemoteControl.call(project, RemoteControl, :complete, [env]) + end + + def complete_struct_fields(%Project{} = project, %Analysis{} = analysis, %Position{} = position) do + RemoteControl.call(project, RemoteControl, :complete_struct_fields, [ + analysis, + position + ]) + end + + def definition(%Project{} = project, %Document{} = document, %Position{} = position) do + RemoteControl.call(project, RemoteControl, :definition, [document, position]) + end + + def references( + %Project{} = project, + %Analysis{} = analysis, + %Position{} = position, + include_definitions? + ) do + RemoteControl.call(project, RemoteControl, :references, [ + analysis, + position, + include_definitions? + ]) + end + + def modules_with_prefix(%Project{} = project, prefix) + when is_binary(prefix) or is_atom(prefix) do + RemoteControl.call(project, RemoteControl, :modules_with_prefix, [prefix]) + end + + def modules_with_prefix(%Project{} = project, prefix, predicate) + when is_binary(prefix) or is_atom(prefix) do + RemoteControl.call(project, RemoteControl, :modules_with_prefix, [prefix, predicate]) + end + + @spec docs(Project.t(), module()) :: {:ok, CodeIntelligence.Docs.t()} | {:error, any()} + def docs(%Project{} = project, module, opts \\ []) when is_atom(module) do + RemoteControl.call(project, RemoteControl, :docs, [module, opts]) + end + + def register_listener(%Project{} = project, listener_pid, message_types) + when is_pid(listener_pid) and is_list(message_types) do + RemoteControl.call(project, RemoteControl, :register_listener, [ + listener_pid, + message_types + ]) + end + + def broadcast(%Project{} = project, message) do + RemoteControl.call(project, RemoteControl, :broadcast, [message]) + end + + def reindex(%Project{} = project) do + RemoteControl.call(project, RemoteControl, :reindex, []) + end + + def index_running?(%Project{} = project) do + RemoteControl.call(project, RemoteControl, :index_running?, []) + end + + def resolve_entity(%Project{} = project, %Analysis{} = analysis, %Position{} = position) do + RemoteControl.call(project, RemoteControl, :resolve_entity, [analysis, position]) + end + + def struct_definitions(%Project{} = project) do + RemoteControl.call(project, RemoteControl, :struct_definitions, []) + end + + def document_symbols(%Project{} = project, %Document{} = document) do + RemoteControl.call(project, RemoteControl, :document_symbols, [document]) + end + + def workspace_symbols(%Project{} = project, query) do + RemoteControl.call(project, RemoteControl, :workspace_symbols, [query]) + end +end diff --git a/engine/lib/engine/api/messages.ex b/engine/lib/engine/api/messages.ex new file mode 100644 index 00000000..fa1baaad --- /dev/null +++ b/engine/lib/engine/api/messages.ex @@ -0,0 +1,139 @@ +defmodule Lexical.RemoteControl.Api.Messages do + alias Lexical.Project + + import Record + defrecord :project_compile_requested, project: nil, build_number: 0 + + defrecord :project_compiled, + project: nil, + build_number: 0, + status: :successful, + diagnostics: [], + elapsed_ms: 0 + + defrecord :filesystem_event, project: nil, uri: nil, event_type: nil + + defrecord :file_changed, uri: nil, from_version: nil, to_version: nil, open?: false + + defrecord :file_compile_requested, project: nil, build_number: 0, uri: nil + + defrecord :file_compiled, + project: nil, + build_number: 0, + uri: nil, + status: :successful, + diagnostics: [], + elapsed_ms: 0 + + defrecord :file_deleted, project: nil, uri: nil + + defrecord :module_updated, file: nil, name: nil, functions: [], macros: [], struct: nil + + defrecord :project_diagnostics, project: nil, build_number: 0, diagnostics: [] + + defrecord :file_diagnostics, project: nil, build_number: 0, uri: nil, diagnostics: [] + + defrecord :project_progress, label: nil, message: nil, stage: :report + + defrecord :percent_progress, label: nil, message: nil, stage: :report, max: 0, delta: 0 + + defrecord :struct_discovered, module: nil, fields: [] + + defrecord :project_index_ready, project: nil + + defrecord :project_reindex_requested, project: nil + + defrecord :project_reindexed, project: nil, elapsed_ms: 0, status: :success + + @type compile_status :: :successful | :error + @type name_and_arity :: {atom, non_neg_integer} + @type field_list :: Keyword.t() | [atom] + @type diagnostics :: [Mix.Task.Compiler.Diagnostic.t()] + @type maybe_version :: nil | non_neg_integer() + + @type project_compile_requested :: + record(:project_compile_requested, + project: Lexical.Project.t(), + build_number: non_neg_integer() + ) + @type project_compiled :: + record(:project_compiled, + project: Lexical.Project.t(), + build_number: non_neg_integer(), + status: compile_status, + elapsed_ms: non_neg_integer + ) + + @type filesystem_event :: + record(:filesystem_event, + project: Project.t(), + uri: Lexical.uri(), + event_type: :created | :updated | :deleted + ) + + @type file_changed :: + record(:file_changed, + uri: Lexical.uri(), + from_version: maybe_version, + to_version: maybe_version, + open?: boolean() + ) + + @type file_compile_requested :: + record(:file_compile_requested, + project: Lexical.Project.t(), + build_number: non_neg_integer(), + uri: Lexical.uri() + ) + + @type file_compiled :: + record(:file_compiled, + project: Lexical.Project.t(), + build_number: non_neg_integer(), + uri: Lexical.uri(), + status: compile_status, + elapsed_ms: non_neg_integer + ) + + @type module_updated :: + record(:module_updated, + name: module(), + functions: [name_and_arity], + macros: [name_and_arity], + struct: field_list + ) + + @type project_diagnostics :: + record(:project_diagnostics, + project: Lexical.Project.t(), + diagnostics: diagnostics() + ) + + @type file_diagnostics :: + record(:file_diagnostics, + project: Lexical.Project.t(), + uri: Lexical.uri(), + diagnostics: diagnostics() + ) + + @type project_progress :: + record(:project_progress, + label: String.t(), + message: String.t() | integer(), + stage: :prepare | :begin | :report | :complete + ) + + @type struct_discovered :: record(:struct_discovered, module: module(), fields: field_list()) + + @type project_index_ready :: record(:project_index_ready, project: Lexical.Project.t()) + + @type project_reindex_requested :: + record(:project_reindex_requested, project: Lexical.Project.t()) + + @type project_reindexed :: + record(:project_reindexed, + project: Lexical.Project.t(), + elapsed_ms: non_neg_integer(), + status: :success | {:error, term()} + ) +end diff --git a/engine/lib/engine/api/proxy.ex b/engine/lib/engine/api/proxy.ex new file mode 100644 index 00000000..790af722 --- /dev/null +++ b/engine/lib/engine/api/proxy.ex @@ -0,0 +1,247 @@ +defmodule Lexical.RemoteControl.Api.Proxy do + @moduledoc """ + A bimodal buffering proxy + + This proxy has two modes. In its default mode, it simply forwards function calls to another module, but when + buffering is activated, it will buffer requests and returned canned responses. + When a process calls `start_buffering`, it is monitored, and while it's alive, all messages are buffered. When the + process that calls `start_buffering` exits, the messages that are buffered then have the potential to be emitted. + + Buffered request are subject to the proxy's internal logic. Some requests that are time sensitive + (like formatting) are dropped. Others are deduplicated, while others are reordered. + + The logic follows below + `broadcast` - Buffered - Though, those related to other events, like compilation are subject to + the rules that govern their source events. Progress messages are sent regardless of + buffering. + `schedule_compile` - Buffered - Only one call is kept + `compile_document` - Buffered, though only one call per URI is kept, and if a `schedule_compile` call + was buffered, all `compile_document` calls are dropped + `reindex` - Buffered, though only one call is kept and it is the last thing run. + `index_running?` - Dropped because it requires an immediate response + `format` - Dropped, as it requires an immediate response. Responds immediately with empty changes + + Internally, there are three states: proxying, draining and buffering. + The proxy starts in proxying mode. Then, when start_buffering is called, it changes to draining mode. This + mode checks if there are any in-flight calls. If there aren't any, it changes immediately to buffring mode. + If there are in-flight reqeusts, it waits for them to finish, and then switches to buffer mode. Once in buffer + mode, requests are buffered until the process that called `start_buffering` exits. When that happens, then + the requests are de-duplicated and run, and then the proxy returns to proxying mode. + + """ + + alias Lexical.Document + alias Lexical.Document.Changes + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Api.Messages + alias Lexical.RemoteControl.Api.Proxy.BufferingState + alias Lexical.RemoteControl.Api.Proxy.DrainingState + alias Lexical.RemoteControl.Api.Proxy.ProxyingState + alias Lexical.RemoteControl.Api.Proxy.Records + alias Lexical.RemoteControl.CodeMod + alias Lexical.RemoteControl.Commands + + import Messages + import Record + import Records, only: :macros + + @behaviour :gen_statem + + defrecord :buffer, contents: nil, return: :ok + defrecord :drop, contents: nil, return: :ok + + # public API + + def start_buffering do + start_buffering(self()) + end + + def start_buffering(caller) when is_pid(caller) do + :gen_statem.call(__MODULE__, {:start_buffering, caller}) + end + + # proxied functions + + def broadcast(percent_progress() = message) do + RemoteControl.Dispatch.broadcast(message) + end + + def broadcast(message) do + mfa = to_mfa(RemoteControl.Dispatch.broadcast(message)) + :gen_statem.call(__MODULE__, buffer(contents: mfa)) + end + + def schedule_compile(force? \\ false) do + project = RemoteControl.get_project() + + mfa = to_mfa(RemoteControl.Build.schedule_compile(project, force?)) + :gen_statem.call(__MODULE__, buffer(contents: mfa)) + end + + def compile_document(document) do + project = RemoteControl.get_project() + + mfa = to_mfa(RemoteControl.Build.compile_document(project, document)) + + :gen_statem.call(__MODULE__, buffer(contents: mfa)) + end + + def reindex do + mfa = to_mfa(Commands.Reindex.perform()) + :gen_statem.call(__MODULE__, buffer(contents: mfa)) + end + + def index_running? do + mfa = to_mfa(Commands.Reindex.running?()) + :gen_statem.call(__MODULE__, drop(contents: mfa, return: false)) + end + + def format(%Document{} = document) do + mfa = to_mfa(CodeMod.Format.edits(document)) + drop = drop(contents: mfa, return: {:ok, Changes.new(document, [])}) + :gen_statem.call(__MODULE__, drop) + end + + # utility functions + + def buffering? do + :gen_statem.call(__MODULE__, :buffering?) + end + + # :gen_statem callbacks + def start_link do + :gen_statem.start_link({:local, __MODULE__}, __MODULE__, [], []) + end + + @impl :gen_statem + def init(_) do + {:ok, :proxying, ProxyingState.new()} + end + + def child_spec(_) do + %{ + id: __MODULE__, + start: {__MODULE__, :start_link, []} + } + end + + @impl :gen_statem + def callback_mode, do: :state_functions + + # callbacks for proxying mode + + def proxying({:call, from}, {:start_buffering, caller}, %ProxyingState{} = state) do + Process.monitor(caller) + buffering_state = BufferingState.new(caller) + + if ProxyingState.empty?(state) do + {:next_state, :buffering, buffering_state, {:reply, from, :ok}} + else + draining_state = DrainingState.new(buffering_state, state) + {:next_state, :draining, draining_state, {:reply, from, :ok}} + end + end + + def proxying({:call, from}, buffer(contents: contents), %ProxyingState{} = state) do + state = ProxyingState.apply_mfa(state, from, contents) + + {:keep_state, state} + end + + def proxying({:call, from}, drop(contents: contents), state) do + state = ProxyingState.apply_mfa(state, from, contents) + {:keep_state, state} + end + + def proxying({:call, from}, :buffering?, state) do + {:keep_state, state, {:reply, from, false}} + end + + def proxying(:info, {ref, reply}, %ProxyingState{} = state) when is_reference(ref) do + ProxyingState.reply(state, ref, reply) + {:keep_state, state} + end + + def proxying(:info, {:DOWN, ref, _, _, _}, %ProxyingState{} = state) do + # Handle the DOWN from the task + new_state = ProxyingState.consume_reply(state, ref) + {:keep_state, new_state} + end + + # Callbacks for the draining mode + + def draining(:info, {ref, reply}, %DrainingState{} = state) when is_reference(ref) do + DrainingState.reply(state, ref, reply) + + {:keep_state, state} + end + + def draining({:call, from}, {:start_buffering, _}, %DrainingState{} = state) do + initiator_pid = state.buffering_state.initiator_pid + {:keep_state, state, {:reply, from, {:error, {:already_buffering, initiator_pid}}}} + end + + def draining( + {:call, from}, + buffer(contents: mfa() = mfa, return: return), + %DrainingState{} = state + ) do + state = DrainingState.add_mfa(state, mfa) + {:keep_state, state, {:reply, from, return}} + end + + def draining({:call, from}, drop(return: return), %DrainingState{} = state) do + {:keep_state, state, {:reply, from, return}} + end + + def draining({:call, from}, :buffering?, state) do + {:keep_state, state, {:reply, from, true}} + end + + def draining(:info, {:DOWN, ref, _, _, _}, %DrainingState{} = state) do + new_state = DrainingState.consume_reply(state, ref) + + if DrainingState.drained?(new_state) do + {:next_state, :buffering, state.buffering_state} + else + {:keep_state, state} + end + end + + # Callbacks for buffering mode + + def buffering({:call, from}, {:start_buffering, _}, %BufferingState{} = state) do + {:keep_state, state, {:reply, from, {:error, {:already_buffering, state.initiator_pid}}}} + end + + def buffering( + {:call, from}, + buffer(contents: mfa() = mfa, return: return), + %BufferingState{} = state + ) do + state = BufferingState.add_mfa(state, mfa) + {:keep_state, state, {:reply, from, return}} + end + + def buffering({:call, from}, drop(return: return), %BufferingState{} = state) do + {:keep_state, state, {:reply, from, return}} + end + + def buffering(:info, {:DOWN, _, :process, pid, _}, %BufferingState{initiator_pid: pid} = state) do + state + |> BufferingState.flush() + |> Enum.each(&apply/1) + + {:next_state, :proxying, ProxyingState.new()} + end + + def buffering({:call, from}, :buffering?, state) do + {:keep_state, state, {:reply, from, true}} + end + + # Private + + defp apply(mfa(module: module, function: function, arguments: arguments)) do + apply(module, function, arguments) + end +end diff --git a/engine/lib/engine/api/proxy/buffering_state.ex b/engine/lib/engine/api/proxy/buffering_state.ex new file mode 100644 index 00000000..ea00e51e --- /dev/null +++ b/engine/lib/engine/api/proxy/buffering_state.ex @@ -0,0 +1,146 @@ +defmodule Lexical.RemoteControl.Api.Proxy.BufferingState do + alias Lexical.Document + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Api + alias Lexical.RemoteControl.Build + alias Lexical.RemoteControl.Commands + + import Api.Messages + import Api.Proxy.Records + + defstruct initiator_pid: nil, buffer: [] + + def new(initiator_pid) do + %__MODULE__{initiator_pid: initiator_pid} + end + + def add_mfa(%__MODULE__{} = state, mfa() = mfa_record) do + %__MODULE__{state | buffer: [mfa_record | state.buffer]} + end + + def flush(%__MODULE__{} = state) do + {messages, commands} = + state.buffer + |> Enum.reverse() + |> Enum.split_with(fn value -> + match?(mfa(module: RemoteControl.Dispatch, function: :broadcast), value) + end) + + {project_compile, document_compiles, reindex} = collapse_commands(commands) + + all_commands = [project_compile | Map.values(document_compiles)] + + all_commands + |> Enum.concat(collapse_messages(messages, project_compile, document_compiles)) + |> Enum.filter(&match?(mfa(), &1)) + |> Enum.sort_by(fn mfa(seq: seq) -> seq end) + |> then(fn commands -> + if reindex do + commands ++ [reindex] + else + commands + end + end) + end + + defp collapse_commands(commands) do + # Rules for collapsing commands + # 1. If there's a project compilation requested, remove all document compilations + # 2. Formats can be dropped, as they're only valid for a short time. + # 3. If there's a reindex, do it after the project compilation has finished + + initial_state = %{project_compiles: [], document_compiles: %{}, reindex: nil} + + grouped = + commands + |> Enum.reduce( + initial_state, + fn + mfa(module: Build, function: :schedule_compile) = mfa, acc -> + Map.update(acc, :project_compiles, [mfa], &[mfa | &1]) + + mfa(module: Build, function: :compile_document) = mfa, acc -> + mfa(arguments: [_, document]) = mfa + uri = document.uri + put_in(acc, [:document_compiles, uri], mfa) + + mfa(module: Commands.Reindex) = mfa, acc -> + Map.put(acc, :reindex, mfa) + + _, acc -> + acc + end + ) + + %{ + project_compiles: project_compiles, + document_compiles: document_compiles, + reindex: reindex + } = grouped + + project_compile = + Enum.reduce(project_compiles, nil, fn + mfa(arguments: [_, true]) = mfa, _ -> + mfa + + mfa(arguments: [true]) = mfa, _ -> + mfa + + mfa() = mfa, nil -> + mfa + + _, acc -> + acc + end) + + document_compiles = + if project_compile do + %{} + else + for {uri, indexed} <- document_compiles, Document.Store.open?(uri), into: %{} do + {uri, indexed} + end + end + + {project_compile, document_compiles, reindex} + end + + defp collapse_messages(messages, project_compile, document_compiles) do + # Rules for collapsing messages + # 1. If the message is document-centric, discard it if the document isn't open. + # 2. It's probably safe to drop all file compile requested messages + # 3. File diagnostics can be dropped if + # a. There is a document compile command for that uri + # b. There is a project compile requested + # 4. Progress messages should still be sent to dispatch, even when buffering + + Enum.filter(messages, fn + mfa(arguments: [file_compile_requested()]) -> + false + + mfa(arguments: [project_compile_requested()]) -> + false + + mfa(arguments: [file_diagnostics(uri: uri)]) -> + not (Map.has_key?(document_compiles, uri) or + match?(project_compile_requested(), project_compile)) + + mfa(arguments: [body]) -> + case fetch_uri(body) do + {:ok, uri} -> + Document.Store.open?(uri) + + :error -> + true + end + end) + end + + defp fetch_uri(filesystem_event(uri: uri)), do: {:ok, uri} + defp fetch_uri(file_changed(uri: uri)), do: {:ok, uri} + defp fetch_uri(file_compile_requested(uri: uri)), do: {:ok, uri} + defp fetch_uri(file_compiled(uri: uri)), do: {:ok, uri} + defp fetch_uri(file_deleted(uri: uri)), do: {:ok, uri} + defp fetch_uri(file_diagnostics(uri: uri)), do: {:ok, uri} + defp fetch_uri(_), do: :error +end diff --git a/engine/lib/engine/api/proxy/draining_state.ex b/engine/lib/engine/api/proxy/draining_state.ex new file mode 100644 index 00000000..4941fc12 --- /dev/null +++ b/engine/lib/engine/api/proxy/draining_state.ex @@ -0,0 +1,30 @@ +defmodule Lexical.RemoteControl.Api.Proxy.DrainingState do + alias Lexical.RemoteControl.Api.Proxy.BufferingState + alias Lexical.RemoteControl.Api.Proxy.ProxyingState + alias Lexical.RemoteControl.Api.Proxy.Records + + import Records + + defstruct [:proxying_state, :buffering_state] + + def new(%BufferingState{} = buffering_state, %ProxyingState{} = proxying_state) do + %__MODULE__{buffering_state: buffering_state, proxying_state: proxying_state} + end + + def drained?(%__MODULE__{} = state) do + ProxyingState.empty?(state.proxying_state) + end + + def consume_reply(%__MODULE__{} = state, ref) when is_reference(ref) do + %__MODULE__{state | proxying_state: ProxyingState.consume_reply(state.proxying_state, ref)} + end + + def reply(%__MODULE__{} = state, ref, reply) do + ProxyingState.reply(state.proxying_state, ref, reply) + end + + def add_mfa(%__MODULE__{} = state, mfa() = mfa) do + new_buffering_state = BufferingState.add_mfa(state.buffering_state, mfa) + %__MODULE__{state | buffering_state: new_buffering_state} + end +end diff --git a/engine/lib/engine/api/proxy/proxying_state.ex b/engine/lib/engine/api/proxy/proxying_state.ex new file mode 100644 index 00000000..81a723e4 --- /dev/null +++ b/engine/lib/engine/api/proxy/proxying_state.ex @@ -0,0 +1,42 @@ +defmodule Lexical.RemoteControl.Api.Proxy.ProxyingState do + alias Lexical.RemoteControl.Api.Proxy.Records + + defstruct refs_to_from: %{} + + import Records + + def new do + %__MODULE__{} + end + + def apply_mfa( + %__MODULE__{} = state, + from, + mfa(module: module, function: function, arguments: arguments) + ) do + task = Task.async(module, function, arguments) + + %__MODULE__{ + state + | refs_to_from: Map.put(state.refs_to_from, task.ref, from) + } + end + + def reply(%__MODULE__{} = state, ref, reply) when is_reference(ref) do + case Map.fetch(state.refs_to_from, ref) do + {:ok, from} -> + :gen_statem.reply(from, reply) + + _ -> + :ok + end + end + + def consume_reply(%__MODULE__{} = state, ref) when is_reference(ref) do + %__MODULE__{state | refs_to_from: Map.delete(state.refs_to_from, ref)} + end + + def empty?(%__MODULE__{} = state) do + Enum.empty?(state.refs_to_from) + end +end diff --git a/engine/lib/engine/api/proxy/records.ex b/engine/lib/engine/api/proxy/records.ex new file mode 100644 index 00000000..5f625b73 --- /dev/null +++ b/engine/lib/engine/api/proxy/records.ex @@ -0,0 +1,37 @@ +defmodule Lexical.RemoteControl.Api.Proxy.Records do + alias Lexical.Formats + + import Record + + defrecord :mfa, module: nil, function: nil, arguments: [], seq: nil + + def mfa(module, function, arguments) do + mfa( + module: module, + function: function, + arguments: arguments, + seq: System.unique_integer([:monotonic]) + ) + end + + defmacro to_mfa(ast) do + {m, f, a} = Macro.decompose_call(ast) + module = Macro.expand(m, __CALLER__) + arity = length(a) + + Code.ensure_compiled!(module) + Code.ensure_loaded!(module) + + unless function_exported?(module, f, arity) do + mfa = Formats.mfa(module, f, arity) + + raise CompileError.message(%{ + file: __CALLER__.file, + line: __CALLER__.line, + description: "No function named #{mfa} defined. Proxy will fail" + }) + end + + quote(do: unquote(__MODULE__).mfa(unquote(m), unquote(f), unquote(a))) + end +end diff --git a/engine/lib/engine/application.ex b/engine/lib/engine/application.ex index fd897802..907fc43d 100644 --- a/engine/lib/engine/application.ex +++ b/engine/lib/engine/application.ex @@ -1,19 +1,37 @@ -defmodule Engine.Application do - # See https://hexdocs.pm/elixir/Application.html - # for more information on OTP Applications +defmodule Lexical.RemoteControl.Application do @moduledoc false + alias Lexical.RemoteControl + use Application + require Logger @impl true def start(_type, _args) do - children = [ - Engine.Worker - ] + children = + if RemoteControl.project_node?() do + [ + RemoteControl.Api.Proxy, + RemoteControl.Commands.Reindex, + RemoteControl.Module.Loader, + {RemoteControl.Dispatch, progress: true}, + RemoteControl.ModuleMappings, + RemoteControl.Build, + RemoteControl.Build.CaptureServer, + RemoteControl.Plugin.Runner.Supervisor, + RemoteControl.Plugin.Runner.Coordinator, + RemoteControl.Search.Store.Backends.Ets, + {RemoteControl.Search.Store, + [ + &RemoteControl.Search.Indexer.create_index/1, + &RemoteControl.Search.Indexer.update_index/2 + ]} + ] + else + [] + end - # See https://hexdocs.pm/elixir/Supervisor.html - # for other strategies and supported options - opts = [strategy: :one_for_one, name: Engine.Supervisor] + opts = [strategy: :one_for_one, name: Lexical.RemoteControl.Supervisor] Supervisor.start_link(children, opts) end end diff --git a/engine/lib/engine/bootstrap.ex b/engine/lib/engine/bootstrap.ex new file mode 100644 index 00000000..d7c43b9a --- /dev/null +++ b/engine/lib/engine/bootstrap.ex @@ -0,0 +1,128 @@ +defmodule Lexical.RemoteControl.Bootstrap do + @moduledoc """ + Bootstraps the remote control node boot sequence. + + We need to first start elixir and mix, then load the project's mix.exs file so we can discover + the project's code paths, which are then added to the code paths from the language server. At this + point, it's safe to start the project, as we should have all the code present to compile the system. + """ + alias Lexical.Project + alias Lexical.RemoteControl + require Logger + + def init(%Project{} = project, document_store_entropy, app_configs) do + Lexical.Document.Store.set_entropy(document_store_entropy) + + Application.put_all_env(app_configs) + + maybe_append_hex_path() + + project_root = Project.root_path(project) + + with :ok <- File.cd(project_root), + {:ok, _} <- Application.ensure_all_started(:elixir), + {:ok, _} <- Application.ensure_all_started(:mix), + {:ok, _} <- Application.ensure_all_started(:logger) do + project = maybe_load_mix_exs(project) + RemoteControl.set_project(project) + Mix.env(:test) + ExUnit.start() + start_logger(project) + maybe_change_directory(project) + Project.ensure_workspace(project) + end + end + + defp maybe_append_hex_path do + hex_ebin = Path.join(["hex-*", "**", "ebin"]) + + hex_path = + :archives + |> Mix.path_for() + |> Path.join(hex_ebin) + |> Path.wildcard() + + case hex_path do + [archives] -> Code.append_path(archives) + _ -> :ok + end + end + + defp start_logger(%Project{} = project) do + log_file_name = + project + |> Project.workspace_path("project.log") + |> String.to_charlist() + + handler_name = :"#{Project.name(project)}_handler" + + config = %{ + config: %{ + file: log_file_name, + max_no_bytes: 1_000_000, + max_no_files: 1 + }, + level: :info + } + + :logger.add_handler(handler_name, :logger_std_h, config) + end + + defp maybe_change_directory(%Project{} = project) do + current_dir = File.cwd!() + + # Note about the following code: + # I tried a bunch of stuff to get it to work, like checking if the + # app is an umbrella (umbrealla? returns false when started in a subapp) + # to no avail. This was the only thing that consistently worked + {:ok, configured_root} = + RemoteControl.Mix.in_project(project, fn _ -> + Mix.Project.config() + |> Keyword.get(:config_path) + |> Path.dirname() + |> Path.join("..") + |> Path.expand() + end) + + unless current_dir == configured_root do + File.cd!(configured_root) + end + end + + defp maybe_load_mix_exs(%Project{} = project) do + # The reason this function exists is to support projects that have the same name as + # one of their dependencies. Prior to this, the project name was based off the directory + # name of the project, and if that's the same as a dependency, the mix project stack will + # raise an error during `deps.safe_compile`, as a project with the same name was already defined. + # Mix itself uses the name of the module that the mix.exs defines as the project name, and I figured + # this was a safe default. + + with path when is_binary(path) <- Project.mix_exs_path(project), + compiled = Code.compile_file(path), + {:ok, project_module} <- find_mix_project_module(compiled) do + # We've found the mix project module, but it's now been added to the + # project stack. We need to clear the stack because we use `in_mix_project`, and + # that will fail if the current project is already in the project stack. + # Restarting mix will clear the stack without using private APIs. + Application.stop(:mix) + Application.ensure_all_started(:mix) + Project.set_project_module(project, project_module) + else + _ -> + project + end + end + + defp find_mix_project_module(module_list) do + case Enum.find(module_list, &project_module?/1) do + {module, _bytecode} -> {:ok, module} + nil -> :error + end + end + + defp project_module?({module, _bytecode}) do + function_exported?(module, :project, 0) + end + + defp project_module?(_), do: false +end diff --git a/engine/lib/engine/build.ex b/engine/lib/engine/build.ex new file mode 100644 index 00000000..0137a352 --- /dev/null +++ b/engine/lib/engine/build.ex @@ -0,0 +1,102 @@ +defmodule Lexical.RemoteControl.Build do + alias Lexical.Document + alias Lexical.Project + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Build.Document.Compilers.HEEx + alias Lexical.RemoteControl.Build.State + alias Lexical.VM.Versions + + require Logger + use GenServer + + @timeout_interval_millis 50 + + # Public interface + + def path(%Project{} = project) do + %{elixir: elixir, erlang: erlang} = Versions.current() + erlang_major = erlang |> String.split(".") |> List.first() + elixir_version = Version.parse!(elixir) + elixir_major = "#{elixir_version.major}.#{elixir_version.minor}" + build_root = Project.build_path(project) + Path.join([build_root, "erl-#{erlang_major}", "elixir-#{elixir_major}"]) + end + + def schedule_compile(%Project{} = _project, force? \\ false) do + GenServer.cast(__MODULE__, {:compile, force?}) + end + + def compile_document(%Project{} = _project, %Document{} = document) do + with false <- Path.absname(document.path) == "mix.exs", + false <- HEEx.recognizes?(document) do + GenServer.cast(__MODULE__, {:compile_file, document}) + end + + :ok + end + + # this is for testing + def force_compile_document(%Document{} = document) do + with false <- Path.absname(document.path) == "mix.exs", + false <- HEEx.recognizes?(document) do + GenServer.call(__MODULE__, {:force_compile_file, document}) + end + + :ok + end + + def with_lock(func) do + RemoteControl.with_lock(__MODULE__, func) + end + + # GenServer Callbacks + + def start_link(_) do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + @impl GenServer + def init([]) do + state = State.new(RemoteControl.get_project()) + + with :ok <- State.set_compiler_options() do + {:ok, state, {:continue, :ensure_build_directory}} + end + end + + @impl GenServer + def handle_continue(:ensure_build_directory, %State{} = state) do + State.ensure_build_directory(state) + {:noreply, state} + end + + @impl GenServer + def handle_call({:force_compile_file, %Document{} = document}, _from, %State{} = state) do + State.compile_file(state, document) + {:reply, :ok, state, @timeout_interval_millis} + end + + @impl GenServer + def handle_cast({:compile, force?}, %State{} = state) do + new_state = State.on_project_compile(state, force?) + {:noreply, new_state, @timeout_interval_millis} + end + + @impl GenServer + def handle_cast({:compile_file, %Document{} = document}, %State{} = state) do + new_state = State.on_file_compile(state, document) + {:noreply, new_state, @timeout_interval_millis} + end + + @impl GenServer + def handle_info(:timeout, %State{} = state) do + new_state = State.on_timeout(state) + {:noreply, new_state} + end + + @impl GenServer + def handle_info(msg, %Project{} = project) do + Logger.warning("Undefined message: #{inspect(msg)}") + {:noreply, project} + end +end diff --git a/engine/lib/engine/build/capture_io.ex b/engine/lib/engine/build/capture_io.ex new file mode 100644 index 00000000..02e6b77a --- /dev/null +++ b/engine/lib/engine/build/capture_io.ex @@ -0,0 +1,103 @@ +defmodule Lexical.RemoteControl.Build.CaptureIO do + # Shamelessly stolen from ExUnit's CaptureIO + alias Lexical.RemoteControl.Build + + def capture_io(fun) when is_function(fun, 0) do + capture_io(:stdio, [], fun) + end + + def capture_io(device, fun) when is_atom(device) and is_function(fun, 0) do + capture_io(device, [], fun) + end + + def capture_io(input, fun) when is_binary(input) and is_function(fun, 0) do + capture_io(:stdio, [input: input], fun) + end + + def capture_io(options, fun) when is_list(options) and is_function(fun, 0) do + capture_io(:stdio, options, fun) + end + + def capture_io(device, input, fun) + when is_atom(device) and is_binary(input) and is_function(fun, 0) do + capture_io(device, [input: input], fun) + end + + def capture_io(device, options, fun) + when is_atom(device) and is_list(options) and is_function(fun, 0) do + do_capture_io(map_dev(device), options, fun) + end + + defp map_dev(:stdio), do: :standard_io + defp map_dev(:stderr), do: :standard_error + defp map_dev(other), do: other + + defp do_capture_io(:standard_io, options, fun) do + prompt_config = Keyword.get(options, :capture_prompt, true) + encoding = Keyword.get(options, :encoding, :unicode) + input = Keyword.get(options, :input, "") + + original_gl = Process.group_leader() + {:ok, capture_gl} = StringIO.open(input, capture_prompt: prompt_config, encoding: encoding) + + try do + Process.group_leader(self(), capture_gl) + do_capture_gl(capture_gl, fun) + after + Process.group_leader(self(), original_gl) + end + end + + defp do_capture_io(device, options, fun) do + input = Keyword.get(options, :input, "") + encoding = Keyword.get(options, :encoding, :unicode) + + case Build.CaptureServer.device_capture_on(device, encoding, input) do + {:ok, ref} -> + try do + result = fun.() + output = Build.CaptureServer.device_output(device, ref) + {output, result} + rescue + e -> + output = Build.CaptureServer.device_output(device, ref) + {output, {:exception, e}} + after + Build.CaptureServer.device_capture_off(ref) + end + + {:error, :no_device} -> + raise "could not find IO device registered at #{inspect(device)}" + + {:error, {:changed_encoding, current_encoding}} -> + raise ArgumentError, """ + attempted to change the encoding for a currently captured device #{inspect(device)}. + + Currently set as: #{inspect(current_encoding)} + Given: #{inspect(encoding)} + + If you need to use multiple encodings on a captured device, you cannot \ + run your test asynchronously + """ + + {:error, :input_on_already_captured_device} -> + raise ArgumentError, + "attempted multiple captures on device #{inspect(device)} with input. " <> + "If you need to give an input to a captured device, you cannot run your test asynchronously" + end + end + + defp do_capture_gl(string_io, fun) do + try do + fun.() + catch + kind, reason -> + {:ok, {_input, output}} = StringIO.close(string_io) + {output, {kind, reason}} + else + result -> + {:ok, {_input, output}} = StringIO.close(string_io) + {output, result} + end + end +end diff --git a/engine/lib/engine/build/capture_server.ex b/engine/lib/engine/build/capture_server.ex new file mode 100644 index 00000000..8818a4d4 --- /dev/null +++ b/engine/lib/engine/build/capture_server.ex @@ -0,0 +1,197 @@ +defmodule Lexical.RemoteControl.Build.CaptureServer do + @moduledoc false + @compile {:no_warn_undefined, Logger} + @timeout :infinity + @name __MODULE__ + + use GenServer + + def start_link(_opts) do + GenServer.start_link(__MODULE__, :ok, name: @name) + end + + def device_capture_on(name, encoding, input) do + GenServer.call(@name, {:device_capture_on, name, encoding, input}, @timeout) + end + + def device_output(name, ref) do + GenServer.call(@name, {:device_output, name, ref}, @timeout) + end + + def device_capture_off(ref) do + GenServer.call(@name, {:device_capture_off, ref}, @timeout) + end + + def log_capture_on(pid) do + GenServer.call(@name, {:log_capture_on, pid}, @timeout) + end + + def log_capture_off(ref) do + GenServer.call(@name, {:log_capture_off, ref}, @timeout) + end + + ## Callbacks + + def init(:ok) do + state = %{ + devices: %{}, + log_captures: %{}, + log_status: nil + } + + {:ok, state} + end + + def handle_call({:device_capture_on, name, encoding, input}, {caller, _}, config) do + capture_device(name, encoding, input, config, caller) + end + + def handle_call({:device_output, name, ref}, _from, config) do + device = Map.fetch!(config.devices, name) + {_, output} = StringIO.contents(device.pid) + total = byte_size(output) + {_pid, offset} = Map.fetch!(device.refs, ref) + output_size = total - offset + {:reply, binary_part(output, offset, output_size), config} + end + + def handle_call({:device_capture_off, ref}, _from, config) do + {:reply, :ok, release_device(ref, config)} + end + + def handle_call({:log_capture_on, pid}, _from, config) do + ref = Process.monitor(pid) + refs = Map.put(config.log_captures, ref, true) + + if map_size(refs) == 1 do + status = Logger.remove_backend(:console) + {:reply, ref, %{config | log_captures: refs, log_status: status}} + else + {:reply, ref, %{config | log_captures: refs}} + end + end + + def handle_call({:log_capture_off, ref}, _from, config) do + Process.demonitor(ref, [:flush]) + config = remove_log_capture(ref, config) + {:reply, :ok, config} + end + + def handle_info({:DOWN, ref, _, _, _}, config) do + config = remove_log_capture(ref, config) + config = release_device(ref, config) + {:noreply, config} + end + + defp capture_device(name, encoding, input, config, caller) do + case config.devices do + %{^name => device} -> + dead_refs = for {ref, {pid, _}} <- device.refs, not Process.alive?(pid), do: ref + + case dead_refs do + [] -> + capture_existing_device(name, encoding, input, config, caller) + + _ -> + config = Enum.reduce(dead_refs, config, &release_device/2) + capture_device(name, encoding, input, config, caller) + end + + %{} -> + capture_new_device(name, encoding, input, config, caller) + end + end + + defp capture_existing_device(name, encoding, input, config, caller) do + case Map.fetch!(config.devices, name) do + %{input?: input?} when input? or input != "" -> + {:reply, {:error, :input_on_already_captured_device}, config} + + %{encoding: ^encoding} = device -> + {_, output} = StringIO.contents(device.pid) + ref = Process.monitor(caller) + config = put_in(config.devices[name].refs[ref], {caller, byte_size(output)}) + {:reply, {:ok, ref}, config} + + %{encoding: other_encoding} -> + {:reply, {:error, {:changed_encoding, other_encoding}}, config} + end + end + + defp capture_new_device(name, encoding, input, config, caller) do + {:ok, pid} = StringIO.open(input, encoding: encoding) + original_pid = Process.whereis(name) + + try do + Process.unregister(name) + Process.register(pid, name) + rescue + ArgumentError -> + {:reply, {:error, :no_device}, config} + else + _ -> + ref = Process.monitor(caller) + + device = %{ + original_pid: original_pid, + pid: pid, + refs: %{ref => {caller, 0}}, + encoding: encoding, + input?: input != "" + } + + {:reply, {:ok, ref}, put_in(config.devices[name], device)} + end + end + + defp release_device(ref, %{devices: devices} = config) do + Process.demonitor(ref, [:flush]) + + case Enum.find(devices, fn {_, device} -> Map.has_key?(device.refs, ref) end) do + {name, device} -> + case Map.delete(device.refs, ref) do + refs when map_size(refs) == 0 -> + revert_device_to_original_pid(name, device.original_pid) + close_string_io(device.pid) + %{config | devices: Map.delete(devices, name)} + + refs -> + put_in(config.devices[name].refs, refs) + end + + _ -> + config + end + end + + defp revert_device_to_original_pid(name, pid) do + Process.unregister(name) + rescue + ArgumentError -> nil + after + Process.register(pid, name) + end + + defp close_string_io(pid) do + StringIO.close(pid) + rescue + ArgumentError -> nil + end + + defp remove_log_capture(ref, %{log_captures: refs} = config) do + case Map.pop(refs, ref, false) do + {true, refs} -> + maybe_add_console(refs, config.log_status) + %{config | log_captures: refs} + + {false, _refs} -> + config + end + end + + defp maybe_add_console(refs, status) do + if status == :ok and map_size(refs) == 0 do + Logger.add_backend(:console, flush: true) + end + end +end diff --git a/engine/lib/engine/build/document.ex b/engine/lib/engine/build/document.ex new file mode 100644 index 00000000..d1e3a41f --- /dev/null +++ b/engine/lib/engine/build/document.ex @@ -0,0 +1,23 @@ +defmodule Lexical.RemoteControl.Build.Document do + alias Lexical.Document + alias Lexical.RemoteControl.Build + alias Lexical.RemoteControl.Build.Document.Compilers + alias Lexical.RemoteControl.Build.Isolation + + @compilers [Compilers.Config, Compilers.Elixir, Compilers.EEx, Compilers.HEEx, Compilers.NoOp] + + def compile(%Document{} = document) do + compiler = Enum.find(@compilers, & &1.recognizes?(document)) + compile_fun = fn -> compiler.compile(document) end + + case Isolation.invoke(compile_fun) do + {:ok, result} -> + result + + {:error, {exception, stack}} -> + diagnostic = Build.Error.error_to_diagnostic(document, exception, stack, nil) + diagnostics = Build.Error.refine_diagnostics([diagnostic]) + {:error, diagnostics} + end + end +end diff --git a/engine/lib/engine/build/document/compiler.ex b/engine/lib/engine/build/document/compiler.ex new file mode 100644 index 00000000..396d5dd8 --- /dev/null +++ b/engine/lib/engine/build/document/compiler.ex @@ -0,0 +1,26 @@ +defmodule Lexical.RemoteControl.Build.Document.Compiler do + @moduledoc """ + A behaviour for document-level compilers + """ + alias Lexical.Document + alias Lexical.Plugin.V1.Diagnostic + + @type compile_response :: {:ok, [Diagnostic.Result.t()]} | {:error, [Diagnostic.Result.t()]} + + @doc """ + Compiles a document + Compiles a document, returning an error tuple if the document won't compile, + or an ok tuple if it does. In either case, it will also return a list of warnings or errors + """ + @callback compile(Document.t()) :: compile_response() + + @doc """ + Returns true if the document can be compiled by the given compiler. + """ + @callback recognizes?(Document.t()) :: boolean() + + @doc """ + Returns true if the compiler is enabled. + """ + @callback enabled?() :: boolean +end diff --git a/engine/lib/engine/build/document/compilers/config.ex b/engine/lib/engine/build/document/compilers/config.ex new file mode 100644 index 00000000..d135f580 --- /dev/null +++ b/engine/lib/engine/build/document/compilers/config.ex @@ -0,0 +1,119 @@ +defmodule Lexical.RemoteControl.Build.Document.Compilers.Config do + @moduledoc """ + A compiler for elixir configuration + """ + alias Elixir.Features + alias Lexical.Document + alias Lexical.Plugin.V1.Diagnostic + alias Lexical.RemoteControl.Build + alias Lexical.RemoteControl.Build.Error.Location + + @elixir_source "Elixir" + + @behaviour Build.Document.Compiler + require Logger + + @impl true + def enabled?, do: true + + @impl true + def recognizes?(%Document{} = document) do + in_config_dir? = + document.path + |> Path.dirname() + |> String.starts_with?(config_dir()) + + in_config_dir? and Path.extname(document.path) == ".exs" + end + + @impl true + def compile(%Document{} = document) do + if Features.with_diagnostics?() do + compile_with_diagnostics(document) + else + raw_compile(document) + end + end + + defp config_dir do + # This function is called inside a call to `in_project` so we can + # call Mix.Project.config() directly + Mix.Project.config() + |> Keyword.get(:config_path) + |> Path.expand() + |> Path.dirname() + end + + defp raw_compile(%Document{} = document) do + contents = Document.to_string(document) + + try do + Config.Reader.eval!(document.path, contents, env: :test) + {:ok, []} + rescue + e -> + {:error, [to_result(document, e, __STACKTRACE__)]} + end + end + + defp compile_with_diagnostics(%Document{} = document) do + {result, diagnostics} = + apply(Code, :with_diagnostics, [ + # credo:disable-for-previous-line + fn -> + raw_compile(document) + end + ]) + + diagnostic_results = Enum.map(diagnostics, &to_result(document, &1)) + + case result do + {:error, errors} -> + {:error, reject_logged_messages(errors ++ diagnostic_results)} + + _ -> + {:ok, reject_logged_messages(diagnostic_results)} + end + end + + defp to_result(document, error, stack \\ []) + + defp to_result(%Document{} = document, %CompileError{} = error, _stack) do + Diagnostic.Result.new( + document.uri, + error.line, + Exception.message(error), + :error, + @elixir_source + ) + end + + defp to_result(%Document{} = document, %error_type{} = error, _stack) + when error_type in [SyntaxError, TokenMissingError] do + Diagnostic.Result.new( + document.uri, + {error.line, error.column}, + Exception.message(error), + :error, + @elixir_source + ) + end + + defp to_result( + %Document{} = document, + %{position: position, message: message, severity: severity}, + _stack + ) do + Diagnostic.Result.new(document.path, position, message, severity, @elixir_source) + end + + defp to_result(%Document{} = document, %{__exception__: true} = exception, stack) do + message = Exception.message(exception) + position = Location.stack_to_position(stack) + Diagnostic.Result.new(document.path, position, message, :error, @elixir_source) + end + + defp reject_logged_messages(results) do + Enum.reject(results, &(&1.message =~ "have been logged")) + end +end diff --git a/engine/lib/engine/build/document/compilers/eex.ex b/engine/lib/engine/build/document/compilers/eex.ex new file mode 100644 index 00000000..243ef224 --- /dev/null +++ b/engine/lib/engine/build/document/compilers/eex.ex @@ -0,0 +1,133 @@ +defmodule Lexical.RemoteControl.Build.Document.Compilers.EEx do + @moduledoc """ + A compiler for .eex files + """ + alias Lexical.Document + alias Lexical.Plugin.V1.Diagnostic.Result + alias Lexical.RemoteControl.Build + alias Lexical.RemoteControl.Build.Document.Compiler + alias Lexical.RemoteControl.Build.Document.Compilers + + @behaviour Compiler + + @impl true + def recognizes?(%Document{language_id: "eex"}), do: true + def recognizes?(_), do: false + + @impl true + def enabled?, do: true + + @impl true + def compile(%Document{} = document) do + with {:ok, quoted} <- eex_to_quoted(document), + :ok <- eval_quoted(document, quoted) do + compile_quoted(document, quoted) + end + end + + defp compile_quoted(%Document{} = document, quoted) do + with {:error, errors} <- Compilers.Quoted.compile(document, quoted, "EEx") do + {:error, reject_undefined_assigns(errors)} + end + end + + defp eex_to_quoted(%Document{} = document) do + try do + quoted = + document + |> Document.to_string() + |> EEx.compile_string(file: document.path) + + {:ok, quoted} + rescue + error -> + {:error, [error_to_result(document, error)]} + end + end + + @spec eval_quoted(Document.t(), Macro.t()) :: :ok | {:error, [Result.t()]} + def eval_quoted(%Document{} = document, quoted_ast) do + result = + if Elixir.Features.with_diagnostics?() do + eval_quoted_with_diagnostics(quoted_ast, document.path) + else + do_eval_quoted(quoted_ast, document.path) + end + + case result do + {:ok, _eval_result} -> + :ok + + {{:ok, _eval_result}, _} -> + # Ignore warnings for now + # because they will be handled by `compile_quoted/2` + # like: `assign @thing not available in EEx template` + :ok + + {:exception, exception, stack, _quoted_ast} -> + converted = + document + |> Build.Error.error_to_diagnostic(exception, stack, quoted_ast) + |> Map.put(:source, "EEx") + + {:error, [converted]} + + {{:exception, exception, stack, _quoted_ast}, all_errors_and_warnings} -> + converted = Build.Error.error_to_diagnostic(document, exception, stack, quoted_ast) + maybe_diagnostics = Build.Error.diagnostics_from_mix(document, all_errors_and_warnings) + + diagnostics = + [converted | maybe_diagnostics] + |> Enum.reverse() + |> Build.Error.refine_diagnostics() + |> Enum.map(&Map.replace!(&1, :source, "EEx")) + + {:error, diagnostics} + end + end + + defp eval_quoted_with_diagnostics(quoted_ast, path) do + # Using apply to prevent a compile warning on elixir < 1.15 + # credo:disable-for-next-line + apply(Code, :with_diagnostics, [fn -> do_eval_quoted(quoted_ast, path) end]) + end + + def do_eval_quoted(quoted_ast, path) do + eval_heex_quoted? = + quoted_ast + |> Future.Macro.path(&match?({:require, [context: Phoenix.LiveView.TagEngine], _}, &1)) + |> then(&(not is_nil(&1))) + + env = + if eval_heex_quoted? do + # __ENV__ is required for heex quoted evaluations. + Map.put(__ENV__, :file, path) + else + [file: path] + end + + try do + {result, _} = Code.eval_quoted(quoted_ast, [assigns: %{}], env) + {:ok, result} + rescue + exception -> + {filled_exception, stack} = Exception.blame(:error, exception, __STACKTRACE__) + {:exception, filled_exception, stack, quoted_ast} + end + end + + defp reject_undefined_assigns(errors) do + # NOTE: Ignoring error for assigns makes sense, + # because we don't want such a error report, + # for example: `<%= @name %>` + Enum.reject(errors, fn %Result{message: message} -> + message =~ ~s[undefined variable "assigns"] + end) + end + + defp error_to_result(%Document{} = document, %EEx.SyntaxError{} = error) do + position = {error.line, error.column} + + Result.new(document.uri, position, error.message, :error, "EEx") + end +end diff --git a/engine/lib/engine/build/document/compilers/elixir.ex b/engine/lib/engine/build/document/compilers/elixir.ex new file mode 100644 index 00000000..e53ab498 --- /dev/null +++ b/engine/lib/engine/build/document/compilers/elixir.ex @@ -0,0 +1,43 @@ +defmodule Lexical.RemoteControl.Build.Document.Compilers.Elixir do + @moduledoc """ + A compiler for elixir source files (.ex and .exs) + """ + + alias Elixir.Features + alias Lexical.Document + alias Lexical.RemoteControl.Build + alias Lexical.RemoteControl.Build.Document.Compilers + + @behaviour Build.Document.Compiler + + @impl true + def recognizes?(%Document{} = doc) do + doc.language_id in ["elixir", "elixir-script"] + end + + @impl true + def enabled?, do: true + + @impl true + def compile(%Document{} = document) do + case to_quoted(document) do + {:ok, quoted} -> + Compilers.Quoted.compile(document, quoted, "Elixir") + + {:error, {meta, message_info, token}} -> + diagnostics = Build.Error.Parse.to_diagnostics(document, meta, message_info, token) + {:error, diagnostics} + end + end + + defp to_quoted(document) do + source_string = Document.to_string(document) + parser_options = [file: document.path] ++ parser_options() + Code.put_compiler_option(:ignore_module_conflict, true) + Code.string_to_quoted(source_string, parser_options) + end + + defp parser_options do + [columns: true, token_metadata: true] + end +end diff --git a/engine/lib/engine/build/document/compilers/heex.ex b/engine/lib/engine/build/document/compilers/heex.ex new file mode 100644 index 00000000..69a0338b --- /dev/null +++ b/engine/lib/engine/build/document/compilers/heex.ex @@ -0,0 +1,84 @@ +defmodule Lexical.RemoteControl.Build.Document.Compilers.HEEx do + @moduledoc """ + A compiler for .heex files + """ + alias Lexical.Document + alias Lexical.Plugin.V1.Diagnostic.Result + alias Lexical.RemoteControl.Build.Document.Compiler + alias Lexical.RemoteControl.Build.Document.Compilers + require Logger + + @behaviour Compiler + + def recognizes?(%Document{language_id: "phoenix-heex"}), do: true + def recognizes?(%Document{language_id: "heex"}), do: true + def recognizes?(_), do: false + + def enabled? do + true + end + + def compile(%Document{} = document) do + with :ok <- eval_heex_quoted(document) do + compile_eex_quoted(document) + end + end + + defp eval_heex_quoted(document) do + with {:ok, quoted} <- heex_to_quoted(document) do + Compilers.EEx.eval_quoted(document, quoted) + end + end + + defp compile_eex_quoted(document) do + with {:error, errors} <- Compilers.EEx.compile(document) do + {:error, reject_undefined_variables(errors)} + end + end + + defp reject_undefined_variables(errors) do + # the undefined variable error is handled by the `eval_heex_quoted` + Enum.reject(errors, fn error -> + error.message =~ "undefined variable" + end) + end + + defp heex_to_quoted(%Document{} = document) do + try do + source = Document.to_string(document) + + opts = + [ + source: source, + file: document.path, + caller: __ENV__, + engine: Phoenix.LiveView.TagEngine, + subengine: Phoenix.LiveView.Engine, + tag_handler: Phoenix.LiveView.HTMLEngine + ] + + quoted = EEx.compile_string(source, opts) + + {:ok, quoted} + rescue + error -> + {:error, [error_to_result(document, error)]} + end + end + + defp error_to_result(%Document{} = document, %EEx.SyntaxError{} = error) do + position = {error.line, error.column} + + Result.new(document.uri, position, error.message, :error, "EEx") + end + + defp error_to_result(document, %error_struct{} = error) + when error_struct in [ + SyntaxError, + TokenMissingError, + Phoenix.LiveView.Tokenizer.ParseError + ] do + position = {error.line, error.column} + Result.new(document.uri, position, error.description, :error, "HEEx") + end +end diff --git a/engine/lib/engine/build/document/compilers/no_op.ex b/engine/lib/engine/build/document/compilers/no_op.ex new file mode 100644 index 00000000..c04bc91a --- /dev/null +++ b/engine/lib/engine/build/document/compilers/no_op.ex @@ -0,0 +1,14 @@ +defmodule Lexical.RemoteControl.Build.Document.Compilers.NoOp do + @moduledoc """ + A no-op, catch-all compiler. Always enabled, recognizes everything and returns no errors + """ + alias Lexical.RemoteControl.Build.Document + + @behaviour Document.Compiler + + def recognizes?(_), do: true + + def enabled?, do: true + + def compile(_), do: {:ok, []} +end diff --git a/engine/lib/engine/build/document/compilers/quoted.ex b/engine/lib/engine/build/document/compilers/quoted.ex new file mode 100644 index 00000000..94551b50 --- /dev/null +++ b/engine/lib/engine/build/document/compilers/quoted.ex @@ -0,0 +1,282 @@ +defmodule Lexical.RemoteControl.Build.Document.Compilers.Quoted do + alias Elixir.Features + alias Lexical.Ast + alias Lexical.Document + alias Lexical.RemoteControl.Build + alias Lexical.RemoteControl.ModuleMappings + + import Lexical.RemoteControl.Build.CaptureIO, only: [capture_io: 2] + + def compile(%Document{} = document, quoted_ast, compiler_name) do + prepare_compile(document.path) + + quoted_ast = + if document.language_id == "elixir-script" do + wrap_top_level_forms(quoted_ast) + else + quoted_ast + end + + {status, diagnostics} = + if Features.with_diagnostics?() do + do_compile(quoted_ast, document) + else + do_compile_and_capture_io(quoted_ast, document) + end + + {status, Enum.map(diagnostics, &replace_source(&1, compiler_name))} + end + + defp do_compile(quoted_ast, document) do + old_modules = ModuleMappings.modules_in_file(document.path) + + case compile_quoted_with_diagnostics(quoted_ast, document.path) do + {{:ok, modules}, []} -> + purge_removed_modules(old_modules, modules) + {:ok, []} + + {{:ok, modules}, all_errors_and_warnings} -> + purge_removed_modules(old_modules, modules) + + diagnostics = + document + |> Build.Error.diagnostics_from_mix(all_errors_and_warnings) + |> Build.Error.refine_diagnostics() + + {:ok, diagnostics} + + {{:exception, exception, stack, quoted_ast}, all_errors_and_warnings} -> + converted = Build.Error.error_to_diagnostic(document, exception, stack, quoted_ast) + maybe_diagnostics = Build.Error.diagnostics_from_mix(document, all_errors_and_warnings) + + diagnostics = + [converted | maybe_diagnostics] + |> Enum.reverse() + |> Build.Error.refine_diagnostics() + + {:error, diagnostics} + end + end + + defp do_compile_and_capture_io(quoted_ast, document) do + # credo:disable-for-next-line Credo.Check.Design.TagTODO + # TODO: remove this function once we drop support for Elixir 1.14 + old_modules = ModuleMappings.modules_in_file(document.path) + compile = fn -> safe_compile_quoted(quoted_ast, document.path) end + + case capture_io(:stderr, compile) do + {captured_messages, {:error, {:exception, {exception, _inner_stack}, stack}}} -> + error = Build.Error.error_to_diagnostic(document, exception, stack, []) + diagnostics = Build.Error.message_to_diagnostic(document, captured_messages) + + {:error, [error | diagnostics]} + + {captured_messages, {:exception, exception, stack, quoted_ast}} -> + error = Build.Error.error_to_diagnostic(document, exception, stack, quoted_ast) + diagnostics = Build.Error.message_to_diagnostic(document, captured_messages) + refined = Build.Error.refine_diagnostics([error | diagnostics]) + + {:error, refined} + + {"", {:ok, modules}} -> + purge_removed_modules(old_modules, modules) + {:ok, []} + + {captured_warnings, {:ok, modules}} -> + purge_removed_modules(old_modules, modules) + + diagnostics = + document + |> Build.Error.message_to_diagnostic(captured_warnings) + |> Build.Error.refine_diagnostics() + + {:ok, diagnostics} + end + end + + defp prepare_compile(path) do + # If we're compiling a mix.exs file, the after compile callback from + # `use Mix.Project` will blow up if we add the same project to the project stack + # twice. Preemptively popping it prevents that error from occurring. + if Path.basename(path) == "mix.exs" do + Mix.ProjectStack.pop() + end + + Mix.Task.run(:loadconfig) + end + + @dialyzer {:nowarn_function, compile_quoted_with_diagnostics: 2} + + defp compile_quoted_with_diagnostics(quoted_ast, path) do + # Using apply to prevent a compile warning on elixir < 1.15 + # credo:disable-for-next-line + apply(Code, :with_diagnostics, [fn -> safe_compile_quoted(quoted_ast, path) end]) + end + + defp safe_compile_quoted(quoted_ast, path) do + try do + {:ok, Code.compile_quoted(quoted_ast, path)} + rescue + exception -> + {filled_exception, stack} = Exception.blame(:error, exception, __STACKTRACE__) + {:exception, filled_exception, stack, quoted_ast} + end + end + + defp purge_removed_modules(old_modules, new_modules) do + new_modules = MapSet.new(new_modules, fn {module, _bytecode} -> module end) + old_modules = MapSet.new(old_modules) + + old_modules + |> MapSet.difference(new_modules) + |> Enum.each(fn to_remove -> + :code.purge(to_remove) + :code.delete(to_remove) + end) + end + + defp replace_source(result, source) do + Map.put(result, :source, source) + end + + @doc false + def wrap_top_level_forms({:__block__, meta, nodes}) do + {chunks, _vars} = + nodes + |> Enum.chunk_by(&should_wrap?/1) + |> Enum.with_index() + |> Enum.flat_map_reduce([], fn {[node | _] = nodes, i}, vars -> + if should_wrap?(node) do + {wrapped, vars} = wrap_nodes(nodes, vars, i) + {[wrapped], vars} + else + {nodes, vars} + end + end) + + {:__block__, meta, chunks} + end + + def wrap_top_level_forms(ast) do + wrap_top_level_forms({:__block__, [], [ast]}) + end + + defp wrap_nodes(nodes, vars, i) do + module_name = :"lexical_wrapper_#{i}" + {nodes, new_vars} = suppress_and_extract_vars(nodes) + + quoted = + quote do + defmodule unquote(module_name) do + def __lexical_wrapper__([unquote_splicing(vars)]) do + (unquote_splicing(nodes)) + end + end + end + + {quoted, new_vars ++ vars} + end + + @allowed_top_level [:defmodule, :alias, :import, :require, :use] + defp should_wrap?({allowed, _, _}) when allowed in @allowed_top_level, do: false + defp should_wrap?(_), do: true + + @doc false + # This function replaces all unused variables with `_` in order + # to suppress warnings while accumulating those vars. The approach + # here is bottom-up, starting from the last expression and working + # back to the beginning: + # + # - If the expression is an assignment, collect vars from the LHS, + # replacing them with `_` if they haven't been referenced, then + # collect references from the RHS. + # - If the expression isn't an assignment, just collect references. + # - Note that pinned vars on the LHS of an assignment are references. + # + def suppress_and_extract_vars(quoted) + + def suppress_and_extract_vars(list) when is_list(list) do + list + |> Enum.reverse() + |> do_suppress_and_extract_vars() + end + + def suppress_and_extract_vars({:__block__, meta, nodes}) do + {nodes, vars} = suppress_and_extract_vars(nodes) + {{:__block__, meta, nodes}, vars} + end + + def suppress_and_extract_vars(expr) do + {[expr], vars} = suppress_and_extract_vars([expr]) + {expr, vars} + end + + defp do_suppress_and_extract_vars(list, acc \\ [], references \\ [], vars \\ []) + + defp do_suppress_and_extract_vars([expr | rest], acc, references, vars) do + {expr, new_vars} = suppress_and_extract_vars_from_expr(expr, references) + new_references = extract_references_from_expr(expr) + + do_suppress_and_extract_vars( + rest, + [expr | acc], + new_references ++ references, + new_vars ++ vars + ) + end + + defp do_suppress_and_extract_vars([], acc, _references, vars) do + {acc, vars} + end + + defp suppress_and_extract_vars_from_expr({:=, meta, [left, right]}, references) do + {left, left_vars} = + Ast.prewalk_vars(left, [], fn + {:^, _, _} = pinned, acc -> + {pinned, acc} + + {name, meta, context} = var, acc -> + if Ast.has_var?(references, name, context) do + {var, [{name, [], context} | acc]} + else + {{:_, meta, nil}, [var | acc]} + end + end) + + {right, right_vars} = suppress_and_extract_vars_from_expr(right, references) + + {{:=, meta, [left, right]}, left_vars ++ right_vars} + end + + defp suppress_and_extract_vars_from_expr(other, _references) do + {other, []} + end + + defp extract_references_from_expr({:=, _, [left, right]}) do + {_, left_references} = + Ast.prewalk_vars(left, [], fn + {:^, _, [referenced_var]}, acc -> + {:ok, [referenced_var | acc]} + + node, acc -> + {node, acc} + end) + + right_references = extract_references_from_expr(right) + + left_references ++ right_references + end + + defp extract_references_from_expr(expr) do + {_, references} = + Ast.prewalk_vars(expr, [], fn + {:^, _, _}, acc -> + {:ok, acc} + + var, acc -> + {:ok, [var | acc]} + end) + + references + end +end diff --git a/engine/lib/engine/build/error.ex b/engine/lib/engine/build/error.ex new file mode 100644 index 00000000..f1ae13fe --- /dev/null +++ b/engine/lib/engine/build/error.ex @@ -0,0 +1,354 @@ +defmodule Lexical.RemoteControl.Build.Error do + alias Lexical.Ast + alias Lexical.Document + alias Lexical.Plugin.V1.Diagnostic.Result + alias Lexical.RemoteControl.Build.Error.Location + alias Mix.Task.Compiler + + require Logger + + @elixir_source "Elixir" + + @doc """ + Diagnostics can come from compiling the whole project, + from compiling individual files, or from erlang's diagnostics (Code.with_diagnostics since elixir1.15), + so we need to do some post-processing. + + Includes: + 1. Normalize each one to the standard result + 2. Format the message to make it readable in the editor + 3. Remove duplicate messages on the same line + """ + def refine_diagnostics(diagnostics) do + diagnostics + |> Enum.map(fn diagnostic -> + diagnostic + |> normalize() + |> format() + end) + |> Location.uniq() + end + + defp normalize(%Compiler.Diagnostic{} = diagnostic) do + Result.new( + diagnostic.file, + diagnostic.position, + diagnostic.message, + diagnostic.severity, + diagnostic.compiler_name + ) + end + + defp normalize(%Result{} = result) do + result + end + + defp format(%Result{} = result) do + %Result{result | message: format_message(result.message)} + end + + @undefined_function_pattern ~r/ \(expected ([A-Za-z0-9_\.]*) to [^\)]+\)/ + + defp format_message("undefined" <> _ = message) do + # All undefined function messages explain the *same* thing inside the parentheses + String.replace(message, @undefined_function_pattern, "") + end + + defp format_message(message) when is_binary(message) do + maybe_format_unused(message) + end + + defp maybe_format_unused(message) do + # Same reason as the `undefined` message above, we can remove the things in parentheses + case String.split(message, "is unused (", parts: 2) do + [prefix, _] -> + prefix <> "is unused" + + _ -> + message + end + end + + @doc """ + The `diagnostics_from_mix/2` is only for Elixir version > 1.15 + + From 1.15 onwards `with_diagnostics` can return some compile-time errors, + more details: https://github.com/elixir-lang/elixir/pull/12742 + """ + def diagnostics_from_mix(%Document{} = doc, all_errors_and_warnings) + when is_list(all_errors_and_warnings) do + for error_or_wanning <- all_errors_and_warnings do + %{position: pos, message: message, severity: severity} = error_or_wanning + + position = + if span = error_or_wanning[:span] do + Location.range(doc, pos, span) + else + pos + end + + Result.new(doc.uri, position, message, severity, @elixir_source) + end + end + + def error_to_diagnostic( + %Document{} = source, + %CompileError{} = compile_error, + _stack, + _quoted_ast + ) do + path = compile_error.file || source.path + + Result.new( + path, + Location.position(compile_error.line), + compile_error.description, + :error, + @elixir_source + ) + end + + def error_to_diagnostic( + %Document{} = source, + %FunctionClauseError{} = function_clause, + stack, + _quoted_ast + ) do + [{_module, _function, _arity, context} | _] = stack + message = Exception.message(function_clause) + position = Location.context_to_position(context) + Result.new(source.uri, position, message, :error, @elixir_source) + end + + def error_to_diagnostic( + %Document{} = source, + %Mix.Error{} = error, + _stack, + _quoted_ast + ) do + message = Exception.message(error) + position = Location.position(1) + Result.new(source.uri, position, message, :error, @elixir_source) + end + + def error_to_diagnostic( + %Document{} = source, + %UndefinedFunctionError{} = undefined_function, + stack, + quoted_ast + ) do + [{module, function, arguments, context} | _] = stack + message = Exception.message(undefined_function) + + position = + if context == [] and is_list(arguments) do + arity = length(arguments) + mfa = {module, function, arity} + mfa_to_position(mfa, quoted_ast) + else + Location.stack_to_position(stack) + end + + Result.new(source.uri, position, message, :error, @elixir_source) + end + + def error_to_diagnostic( + %Document{} = source, + %RuntimeError{} = runtime_error, + _stack, + _quoted_ast + ) do + message = Exception.message(runtime_error) + position = 1 + Result.new(source.uri, position, message, :error, @elixir_source) + end + + def error_to_diagnostic( + %Document{} = source, + %error_struct{} = argument_error, + stack, + _quoted_ast + ) + when error_struct in [ArgumentError, KeyError] do + reversed_stack = Enum.reverse(stack) + + [{_, _, _, context}, {_, call, _, second_to_last_context} | _] = reversed_stack + + pipe_or_struct? = call in [:|>, :__struct__] + expanding? = second_to_last_context[:file] in [~c"expanding macro", ~c"expanding struct"] + message = Exception.message(argument_error) + + position = + if pipe_or_struct? or expanding? do + Location.context_to_position(context) + else + Location.stack_to_position(stack) + end + + Result.new(source.uri, position, message, :error, @elixir_source) + end + + def error_to_diagnostic(%Document{} = source, %module{} = exception, stack, _quoted_ast) + when module in [ + Protocol.UndefinedError, + ExUnit.DuplicateTestError, + ExUnit.DuplicateDescribeError + ] do + message = Exception.message(exception) + position = Location.stack_to_position(stack) + Result.new(source.uri, position, message, :error, @elixir_source) + end + + def message_to_diagnostic(%Document{} = document, message_string) do + message_string + |> extract_individual_messages() + |> Enum.map(&do_message_to_diagnostic(document, &1)) + |> Enum.reject(&is_nil/1) + end + + defp extract_individual_messages(messages) do + messages + |> extract_individual_messages([], []) + end + + defp extract_individual_messages(<<>>, current_message, messages) do + [current_message | messages] + |> Enum.map(&to_message/1) + |> Enum.reverse() + end + + defp extract_individual_messages(<<"error:", rest::binary>>, current_message, messages) do + extract_individual_messages(rest, ["error:"], [current_message | messages]) + end + + defp extract_individual_messages(<<"warning:", rest::binary>>, current_message, messages) do + extract_individual_messages(rest, ["warning:"], [current_message | messages]) + end + + defp extract_individual_messages(<>, current_message, messages) do + extract_individual_messages(rest, [current_message, c], messages) + end + + defp to_message(iodata) do + iodata + |> IO.iodata_to_binary() + |> String.trim() + end + + defp mfa_to_position({module, function, arity}, quoted_ast) do + # Because elixir's Code module has less than stellr line reporting, I think the best we can + # do here is to get the error from the stack trace + + module_path = safe_split(module) + + traverser = fn + {{:., _, [{:__aliases__, _, ^module_path}, ^function]}, context, arguments} = ast, _ + when length(arguments) == arity -> + {ast, context} + + {{:., _, [^module_path, ^function]}, context, arguments} = ast, _ + when length(arguments) == arity -> + {ast, context} + + ast, nil -> + {ast, nil} + + ast, found -> + {ast, found} + end + + {_, context} = Macro.traverse(quoted_ast, nil, traverser, fn ast, acc -> {ast, acc} end) + + cond do + is_nil(context) -> + Location.position(0) + + Keyword.has_key?(context, :line) and Keyword.has_key?(context, :column) -> + Location.position(context[:line], context[:column]) + + Keyword.has_key?(context, :line) -> + Location.position(context[:line]) + + true -> + nil + end + end + + defp safe_split(module) do + case Ast.Module.safe_split(module, as: :atoms) do + {:elixir, segments} -> segments + {:erlang, [erlang_module]} -> erlang_module + end + end + + defp do_message_to_diagnostic(_, "") do + nil + end + + defp do_message_to_diagnostic(_, "warning: redefining module" <> _) do + nil + end + + defp do_message_to_diagnostic(%Document{} = document, message) do + message_lines = String.split(message, "\n") + + with {:ok, location_line} <- find_location(message_lines), + {:ok, {file, line, mfa}} <- parse_location(location_line) do + file = + if blank?(file) do + document.path + else + file + end + + Result.new(file, line, message, :warning, @elixir_source, mfa) + else + _ -> + nil + end + end + + # This regex captures file / line based locations (file.ex:3) + @file_and_line_re ~r/\s+([^:]+):(\d+)/ + # This regex matches the more detailed locations that contain the + # file, line, and the mfa of the error + @location_re ~r/\s+([^:]+):(\d+):\s+([^\.]+)\.(\w+)\/(\d+)?/ + def parse_location(location_string) do + with [] <- Regex.scan(@location_re, location_string), + [[_, file, line]] <- Regex.scan(@file_and_line_re, location_string) do + line = String.to_integer(line) + location = {file, line, nil} + {:ok, location} + else + [[_, file, line, module, function, arity]] -> + line = String.to_integer(line) + module = Module.concat([module]) + function = String.to_atom(function) + arity = String.to_integer(arity) + location = {file, line, {module, function, arity}} + {:ok, location} + + _ -> + :error + end + end + + defp find_location(lines) do + lines + |> Enum.find(fn + line when is_binary(line) -> + Regex.scan(@location_re, line) != [] or Regex.scan(@file_and_line_re, line) != [] + + _ -> + false + end) + |> case do + line when is_binary(line) -> {:ok, line} + nil -> :error + end + end + + defp blank?(s) when is_binary(s) do + String.trim(s) == "" + end +end diff --git a/engine/lib/engine/build/error/location.ex b/engine/lib/engine/build/error/location.ex new file mode 100644 index 00000000..d8f4e92c --- /dev/null +++ b/engine/lib/engine/build/error/location.ex @@ -0,0 +1,97 @@ +defmodule Lexical.RemoteControl.Build.Error.Location do + alias Lexical.Document + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.Plugin.V1.Diagnostic.Result + + require Logger + + def stack_to_position([{_, target, _, _} | rest]) + when target not in [:__FILE__, :__MODULE__] do + stack_to_position(rest) + end + + def stack_to_position([{_, target, _, context} | _rest]) + when target in [:__FILE__, :__MODULE__] do + context_to_position(context) + end + + def stack_to_position([]) do + nil + end + + def context_to_position(context) do + case {context[:line], context[:column]} do + {nil, nil} -> + Logger.error("Invalid context: #{inspect(context)}") + nil + + {line, nil} -> + line + + {line, column} -> + position(line, column) + end + end + + def position(line) do + line + end + + def position(line, column) do + {line, column} + end + + def fetch_range(%Document{} = document, context) do + case {context[:end_line], context[:end_column]} do + {nil, _} -> + :error + + {end_line, end_column} -> + {line, column} = {context[:line], context[:column]} + {:ok, range(document, line, column, end_line, end_column)} + end + end + + def range(%Document{} = document, {line, column}, {end_line, end_column}) do + range(document, line, column, end_line, end_column) + end + + def range(%Document{} = document, line, column, end_line, end_column) do + start_position = Position.new(document, line, column) + end_position = Position.new(document, end_line, end_column) + Range.new(start_position, end_position) + end + + def uniq(diagnostics) do + exacts = Enum.filter(diagnostics, fn diagnostic -> match?(%Range{}, diagnostic.position) end) + + extract_line = fn + %Result{position: {line, _column}} -> line + %Result{position: line} -> line + end + + # Note: Sometimes error and warning appear on one line at the same time + # So we need to uniq by line and severity, + # and :error is always more important than :warning + extract_line_and_severity = &{extract_line.(&1), &1.severity} + + filtered = + diagnostics + |> Enum.filter(fn diagnostic -> not match?(%Range{}, diagnostic.position) end) + |> Enum.sort_by(extract_line_and_severity) + |> Enum.uniq_by(extract_line) + |> reject_zeroth_line() + + exacts ++ filtered + end + + defp reject_zeroth_line(diagnostics) do + # Since 1.15, Elixir has some nonsensical error on line 0, + # e.g.: Can't compile this file + # We can simply ignore it, as there is a more accurate one + Enum.reject(diagnostics, fn diagnostic -> + diagnostic.position == 0 + end) + end +end diff --git a/engine/lib/engine/build/error/parse.ex b/engine/lib/engine/build/error/parse.ex new file mode 100644 index 00000000..e0241601 --- /dev/null +++ b/engine/lib/engine/build/error/parse.ex @@ -0,0 +1,198 @@ +defmodule Lexical.RemoteControl.Build.Error.Parse do + alias Lexical.Document + alias Lexical.Document.Range + alias Lexical.Plugin.V1.Diagnostic.Result + alias Lexical.RemoteControl.Build.Error.Location + + @elixir_source "Elixir" + + # Parse errors happen during Code.string_to_quoted and are raised as SyntaxErrors, and TokenMissingErrors. + def to_diagnostics( + %Document{} = source, + context, + {_error, detail} = message_info, + token + ) + when is_binary(detail) do + # NOTE: mainly for `unexpected token` errors `< 1.16`, + # its details consist of multiple lines, so it is a tuple. + detail_diagnostics = detail_diagnostics(source, detail) + error = message_info_to_binary(message_info, token) + error_diagnostics = to_diagnostics(source, context, error, token) + Location.uniq(detail_diagnostics ++ error_diagnostics) + end + + def to_diagnostics(%Document{} = source, context, message_info, token) + when is_exception(message_info) do + to_diagnostics(source, context, Exception.message(message_info), token) + end + + def to_diagnostics(%Document{} = source, context, message_info, token) do + {start_line_fn, end_line_fn} = + if Features.details_in_context?() do + {&build_end_line_diagnostics_from_context/4, &build_start_line_diagnostics_from_context/4} + else + {&build_start_line_diagnostics/4, &build_end_line_diagnostics/4} + end + + parse_error_diagnostic_functions = [ + end_line_fn, + start_line_fn, + &build_hint_diagnostics/4 + ] + + parse_error_diagnostic_functions + |> Enum.flat_map(& &1.(source, context, message_info, token)) + |> Location.uniq() + end + + @missing_terminator_pattern ~r/missing terminator: \w+/ + defp build_end_line_diagnostics_from_context( + %Document{} = source, + context, + message_info, + token + ) do + message = + cond do + String.starts_with?(message_info, "unexpected") -> + ~s/#{message_info}#{token}, expected `#{context[:expected_delimiter]}`/ + + Regex.match?(@missing_terminator_pattern, message_info) -> + [message] = Regex.run(@missing_terminator_pattern, message_info) + message + + true -> + "#{message_info}#{token}" + end + + case Location.fetch_range(source, context) do + {:ok, %Range{end: end_pos}} -> + [ + Result.new( + source.uri, + {end_pos.line, end_pos.character}, + message, + :error, + @elixir_source + ) + ] + + :error -> + [] + end + end + + defp build_end_line_diagnostics(%Document{} = source, context, message_info, token) do + [end_line_message | _] = String.split(message_info, "\n") + + message = + if String.ends_with?(end_line_message, token) do + end_line_message + else + end_line_message <> token + end + + diagnostic = + Result.new(source.uri, Location.context_to_position(context), message, :error, "Elixir") + + [diagnostic] + end + + defp build_start_line_diagnostics_from_context( + %Document{} = source, + context, + message_info, + token + ) do + opening_delimiter = context[:opening_delimiter] + + if opening_delimiter do + build_opening_delimiter_diagnostics(source, context, opening_delimiter) + else + build_syntax_error_diagnostic(source, context, message_info, token) + end + end + + defp build_opening_delimiter_diagnostics(%Document{} = source, context, opening_delimiter) do + message = + ~s/The `#{opening_delimiter}` here is missing terminator `#{context[:expected_delimiter]}`/ + + opening_delimiter_length = opening_delimiter |> Atom.to_string() |> String.length() + + pos = + Location.range( + source, + context[:line], + context[:column], + context[:line], + context[:column] + opening_delimiter_length + ) + + result = Result.new(source.uri, pos, message, :error, @elixir_source) + [result] + end + + defp build_syntax_error_diagnostic(%Document{} = source, context, message_info, token) do + message = "#{message_info}#{token}" + pos = Location.position(context[:line], context[:column]) + result = Result.new(source.uri, pos, message, :error, @elixir_source) + [result] + end + + @start_line_regex ~r/(\w+) \(for (.*) starting at line (\d+)\)/ + defp build_start_line_diagnostics(%Document{} = source, _context, message_info, _token) do + case Regex.run(@start_line_regex, message_info) do + [_, missing, token, start_line] -> + message = + ~s[The #{format_token(token)} here is missing terminator #{format_token(missing)}] + + position = String.to_integer(start_line) + result = Result.new(source.uri, position, message, :error, @elixir_source) + [result] + + _ -> + [] + end + end + + @hint_regex ~r/(HINT:|hint:\e\[0m|hint:)( .*on line (\d+).*)/m + defp build_hint_diagnostics(%Document{} = source, _context, message_info, _token) do + case Regex.run(@hint_regex, message_info) do + [_whole_message, _hint, message, hint_line] -> + message = "HINT:" <> String.replace(message, ~r/on line \d+/, "here") + position = String.to_integer(hint_line) + result = Result.new(source.uri, position, message, :error, @elixir_source) + [result] + + _ -> + [] + end + end + + defp message_info_to_binary({header, footer}, token) do + header <> token <> footer + end + + @detail_location_re ~r/at line (\d+)/ + defp detail_diagnostics(%Document{} = source, detail) do + case Regex.scan(@detail_location_re, detail) do + [[matched, line_number]] -> + line_number = String.to_integer(line_number) + message = String.replace(detail, matched, "here") + result = Result.new(source.uri, line_number, message, :error, @elixir_source) + [result] + + _ -> + [] + end + end + + defp format_token(token) when is_binary(token) do + if String.contains?(token, "\"") do + String.replace(token, "\"", "`") + else + "`#{token}`" + end + end +end diff --git a/engine/lib/engine/build/isolation.ex b/engine/lib/engine/build/isolation.ex new file mode 100644 index 00000000..4bfd3e00 --- /dev/null +++ b/engine/lib/engine/build/isolation.ex @@ -0,0 +1,25 @@ +defmodule Lexical.RemoteControl.Build.Isolation do + @moduledoc """ + Runs functions in an isolated, monitored process + """ + + @spec invoke((-> term())) :: {:ok, term()} | {:error, term()} + def invoke(function) when is_function(function, 0) do + me = self() + + {pid, ref} = + spawn_monitor(fn -> + send(me, {:result, function.()}) + end) + + receive do + {:result, result} -> + # clean up the DOWN message from the above process in the mailbox. + Process.demonitor(ref, [:flush]) + {:ok, result} + + {:DOWN, ^ref, :process, ^pid, reason} -> + {:error, reason} + end + end +end diff --git a/engine/lib/engine/build/project.ex b/engine/lib/engine/build/project.ex new file mode 100644 index 00000000..f9f59f2c --- /dev/null +++ b/engine/lib/engine/build/project.ex @@ -0,0 +1,128 @@ +defmodule Lexical.RemoteControl.Build.Project do + alias Lexical.Project + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Build + alias Lexical.RemoteControl.Build.Isolation + alias Lexical.RemoteControl.Plugin + alias Mix.Task.Compiler.Diagnostic + + use RemoteControl.Progress + require Logger + + def compile(%Project{} = project, initial?) do + RemoteControl.Mix.in_project(fn _ -> + Mix.Task.clear() + + prepare_for_project_build(initial?) + + compile_fun = fn -> + Mix.Task.clear() + + with_progress building_label(project), fn -> + result = compile_in_isolation() + Mix.Task.run(:loadpaths) + result + end + end + + case compile_fun.() do + {:error, diagnostics} -> + diagnostics = + diagnostics + |> List.wrap() + |> Build.Error.refine_diagnostics() + + {:error, diagnostics} + + {status, diagnostics} when status in [:ok, :noop] -> + Logger.info( + "Compile completed with status #{status} " <> + "Produced #{length(diagnostics)} diagnostics " <> + inspect(diagnostics) + ) + + Build.Error.refine_diagnostics(diagnostics) + end + end) + end + + defp compile_in_isolation do + compile_fun = fn -> Mix.Task.run(:compile, mix_compile_opts()) end + + case Isolation.invoke(compile_fun) do + {:ok, result} -> + result + + {:error, {exception, [{_mod, _fun, _arity, meta} | _]}} -> + diagnostic = %Diagnostic{ + file: Keyword.get(meta, :file), + severity: :error, + message: Exception.message(exception), + compiler_name: "Elixir", + position: Keyword.get(meta, :line, 1) + } + + {:error, [diagnostic]} + end + end + + defp prepare_for_project_build(false = _initial?) do + :ok + end + + defp prepare_for_project_build(true = _initial?) do + if connected_to_internet?() do + with_progress "mix local.hex", fn -> + Mix.Task.run("local.hex", ~w(--force --if-missing)) + end + + with_progress "mix local.rebar", fn -> + Mix.Task.run("local.rebar", ~w(--force --if-missing)) + end + + with_progress "mix deps.get", fn -> + Mix.Task.run("deps.get") + end + else + Logger.warning("Could not connect to hex.pm, dependencies will not be fetched") + end + + with_progress "mix loadconfig", fn -> + Mix.Task.run(:loadconfig) + end + + with_progress "mix deps.compile", fn -> + Mix.Task.run("deps.safe_compile", ~w(--skip-umbrella-children)) + end + + with_progress "loading plugins", fn -> + Plugin.Discovery.run() + end + end + + defp connected_to_internet? do + # While there's no perfect way to check if a computer is connected to the internet, + # it seems reasonable to gate pulling dependenices on a resolution check for hex.pm. + # Yes, it's entirely possible that the DNS server is local, and that the entry is in cache, + # but that's an edge case, and the build will just time out anyways. + case :inet_res.getbyname(~c"hex.pm", :a, 250) do + {:ok, _} -> true + _ -> false + end + end + + def building_label(%Project{} = project) do + "Building #{Project.display_name(project)}" + end + + defp mix_compile_opts do + ~w( + --return-errors + --ignore-module-conflict + --all-warnings + --docs + --debug-info + --no-protocol-consolidation + ) + end +end diff --git a/engine/lib/engine/build/state.ex b/engine/lib/engine/build/state.ex new file mode 100644 index 00000000..baa7aa35 --- /dev/null +++ b/engine/lib/engine/build/state.ex @@ -0,0 +1,261 @@ +defmodule Lexical.RemoteControl.Build.State do + alias Elixir.Features + alias Lexical.Document + alias Lexical.Project + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Api.Messages + alias Lexical.RemoteControl.Build + alias Lexical.RemoteControl.Plugin + alias Lexical.VM.Versions + + require Logger + + import Messages + + use RemoteControl.Progress + + defstruct project: nil, + build_number: 0, + uri_to_document: %{}, + project_compile: :none + + def new(%Project{} = project) do + %__MODULE__{project: project} + end + + def on_timeout(%__MODULE__{} = state) do + new_state = + case state.project_compile do + :none -> state + :force -> compile_project(state, true) + :normal -> compile_project(state, false) + end + + # We need to compile the individual documents even after the project is + # compiled because they might have unsaved changes, and we want that state + # to be the latest state of the project. + new_state = + Enum.reduce(new_state.uri_to_document, state, fn {_uri, document}, state -> + compile_file(state, document) + end) + + %__MODULE__{new_state | uri_to_document: %{}, project_compile: :none} + end + + def on_file_compile(%__MODULE__{} = state, %Document{} = document) do + %__MODULE__{ + state + | uri_to_document: Map.put(state.uri_to_document, document.uri, document) + } + end + + def on_project_compile(%__MODULE__{} = state, force?) do + if force? do + %__MODULE__{state | project_compile: :force} + else + %__MODULE__{state | project_compile: :normal} + end + end + + def ensure_build_directory(%__MODULE__{} = state) do + # If the project directory isn't there, for some reason the main build fails, so we create it here + # to ensure that the build will succeed. + project = state.project + build_path = RemoteControl.Build.path(project) + + unless Versions.compatible?(build_path) do + Logger.info("Build path #{build_path} was compiled on a previous erlang version. Deleting") + + if File.exists?(build_path) do + File.rm_rf(build_path) + end + end + + maybe_delete_old_builds(project) + + unless File.exists?(build_path) do + File.mkdir_p!(build_path) + Versions.write(build_path) + end + end + + defp compile_project(%__MODULE__{} = state, initial?) do + state = increment_build_number(state) + project = state.project + + Build.with_lock(fn -> + compile_requested_message = + project_compile_requested(project: project, build_number: state.build_number) + + RemoteControl.broadcast(compile_requested_message) + {elapsed_us, result} = :timer.tc(fn -> Build.Project.compile(project, initial?) end) + elapsed_ms = to_ms(elapsed_us) + + {compile_message, diagnostics} = + case result do + :ok -> + message = project_compiled(status: :success, project: project, elapsed_ms: elapsed_ms) + + {message, []} + + {:ok, diagnostics} -> + message = project_compiled(status: :success, project: project, elapsed_ms: elapsed_ms) + + {message, List.wrap(diagnostics)} + + {:error, diagnostics} -> + message = project_compiled(status: :error, project: project, elapsed_ms: elapsed_ms) + + {message, List.wrap(diagnostics)} + end + + diagnostics_message = + project_diagnostics( + project: project, + build_number: state.build_number, + diagnostics: diagnostics + ) + + RemoteControl.broadcast(compile_message) + RemoteControl.broadcast(diagnostics_message) + Plugin.diagnose(project, state.build_number) + end) + + state + end + + def compile_file(%__MODULE__{} = state, %Document{} = document) do + state = increment_build_number(state) + project = state.project + + Build.with_lock(fn -> + RemoteControl.broadcast(file_compile_requested(uri: document.uri)) + + safe_compile_func = fn -> + RemoteControl.Mix.in_project(fn _ -> Build.Document.compile(document) end) + end + + {elapsed_us, result} = :timer.tc(fn -> safe_compile_func.() end) + + elapsed_ms = to_ms(elapsed_us) + + {compile_message, diagnostics} = + case result do + {:ok, diagnostics} -> + message = + file_compiled( + project: project, + build_number: state.build_number, + status: :success, + uri: document.uri, + elapsed_ms: elapsed_ms + ) + + {message, diagnostics} + + {:error, diagnostics} -> + message = + file_compiled( + project: project, + build_number: state.build_number, + status: :error, + uri: document.uri, + elapsed_ms: elapsed_ms + ) + + {message, diagnostics} + end + + diagnostics = + file_diagnostics( + project: project, + build_number: state.build_number, + uri: document.uri, + diagnostics: List.wrap(diagnostics) + ) + + RemoteControl.broadcast(compile_message) + RemoteControl.broadcast(diagnostics) + Plugin.diagnose(project, state.build_number, document) + end) + + state + end + + def set_compiler_options do + Code.compiler_options( + parser_options: parser_options(), + tracers: [RemoteControl.Compilation.Tracer] + ) + + :ok + end + + def mix_compile_opts(initial?) do + opts = ~w( + --return-errors + --ignore-module-conflict + --all-warnings + --docs + --debug-info + --no-protocol-consolidation + ) + + if initial? do + ["--force " | opts] + else + opts + end + end + + def building_label(%Project{} = project) do + "Building #{Project.display_name(project)}" + end + + defp to_ms(microseconds) do + microseconds / 1000 + end + + defp parser_options do + [columns: true, token_metadata: true] + end + + defp increment_build_number(%__MODULE__{} = state) do + %__MODULE__{state | build_number: state.build_number + 1} + end + + @two_month_seconds 86_400 * 31 * 2 + defp maybe_delete_old_builds(%Project{} = project) do + build_root = Project.build_path(project) + two_months_ago = System.system_time(:second) - @two_month_seconds + + case File.ls(build_root) do + {:ok, entries} -> + for file_name <- entries, + absolute_path = Path.join(build_root, file_name), + File.dir?(absolute_path), + newest_beam_mtime(absolute_path) <= + two_months_ago do + File.rm_rf!(absolute_path) + end + + _ -> + :ok + end + end + + defp newest_beam_mtime(directory) do + directory + |> Path.join("**/*.beam") + |> Path.wildcard() + |> then(fn + [] -> + 0 + + beam_files -> + beam_files + |> Enum.map(&File.stat!(&1, time: :posix).mtime) + |> Enum.max() + end) + end +end diff --git a/engine/lib/engine/code_action.ex b/engine/lib/engine/code_action.ex new file mode 100644 index 00000000..4bbef10d --- /dev/null +++ b/engine/lib/engine/code_action.ex @@ -0,0 +1,62 @@ +defmodule Lexical.RemoteControl.CodeAction do + alias Lexical.Document + alias Lexical.Document.Changes + alias Lexical.Document.Range + alias Lexical.RemoteControl.CodeAction.Diagnostic + alias Lexical.RemoteControl.CodeAction.Handlers + + defstruct [:title, :kind, :changes, :uri] + + @type code_action_kind :: + :empty + | :quick_fix + | :refactor + | :refactor_extract + | :refactor_inline + | :refactor_rewrite + | :source + | :source_organize_imports + | :source_fix_all + + @type t :: %__MODULE__{ + title: String.t(), + kind: code_action_kind, + changes: Changes.t(), + uri: Lexical.uri() + } + + @handlers [ + Handlers.ReplaceRemoteFunction, + Handlers.ReplaceWithUnderscore, + Handlers.OrganizeAliases, + Handlers.AddAlias, + Handlers.RemoveUnusedAlias + ] + + @spec new(Lexical.uri(), String.t(), code_action_kind(), Changes.t()) :: t() + def new(uri, title, kind, changes) do + %__MODULE__{uri: uri, title: title, changes: changes, kind: kind} + end + + @spec for_range(Document.t(), Range.t(), [Diagnostic.t()], [code_action_kind] | :all) :: [t()] + def for_range(%Document{} = doc, %Range{} = range, diagnostics, kinds) do + results = + Enum.flat_map(@handlers, fn handler -> + if applies?(kinds, handler) do + handler.actions(doc, range, diagnostics) + else + [] + end + end) + + results + end + + defp applies?(:all, _handler_module) do + true + end + + defp applies?(kinds, handler_module) do + kinds -- handler_module.kinds() != kinds + end +end diff --git a/engine/lib/engine/code_action/diagnostic.ex b/engine/lib/engine/code_action/diagnostic.ex new file mode 100644 index 00000000..78b6ee83 --- /dev/null +++ b/engine/lib/engine/code_action/diagnostic.ex @@ -0,0 +1,17 @@ +defmodule Lexical.RemoteControl.CodeAction.Diagnostic do + alias Lexical.Document.Range + + defstruct [:range, :message, :source] + @type message :: String.t() + @type source :: String.t() + @type t :: %__MODULE__{ + range: Range.t(), + message: message() | nil, + source: source() | nil + } + + @spec new(Range.t(), message(), source() | nil) :: t + def new(%Range{} = range, message, source) do + %__MODULE__{range: range, message: message, source: source} + end +end diff --git a/engine/lib/engine/code_action/handler.ex b/engine/lib/engine/code_action/handler.ex new file mode 100644 index 00000000..e02a61b4 --- /dev/null +++ b/engine/lib/engine/code_action/handler.ex @@ -0,0 +1,9 @@ +defmodule Lexical.RemoteControl.CodeAction.Handler do + alias Lexical.Document + alias Lexical.Document.Range + alias Lexical.RemoteControl.CodeAction + alias Lexical.RemoteControl.CodeAction.Diagnostic + + @callback actions(Document.t(), Range.t(), [Diagnostic.t()]) :: [CodeAction.t()] + @callback kinds() :: [CodeAction.code_action_kind()] +end diff --git a/engine/lib/engine/code_action/handlers/add_alias.ex b/engine/lib/engine/code_action/handlers/add_alias.ex new file mode 100644 index 00000000..f3203cdc --- /dev/null +++ b/engine/lib/engine/code_action/handlers/add_alias.ex @@ -0,0 +1,211 @@ +defmodule Lexical.RemoteControl.CodeAction.Handlers.AddAlias do + alias Lexical.Ast + alias Lexical.Ast.Analysis + alias Lexical.Ast.Analysis.Alias + alias Lexical.Document + alias Lexical.Document.Changes + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.Formats + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Analyzer + alias Lexical.RemoteControl.CodeAction + alias Lexical.RemoteControl.CodeIntelligence.Entity + alias Lexical.RemoteControl.CodeMod + alias Lexical.RemoteControl.Modules + alias Lexical.RemoteControl.Search.Fuzzy + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Mix.Tasks.Namespace + alias Sourceror.Zipper + + @behaviour CodeAction.Handler + + @impl CodeAction.Handler + def actions(%Document{} = doc, %Range{} = range, _diagnostics) do + with {:ok, _doc, %Analysis{valid?: true} = analysis} <- + Document.Store.fetch(doc.uri, :analysis), + {:ok, resolved, _} <- Entity.resolve(analysis, range.start), + {:ok, unaliased_module} <- fetch_unaliased_module(analysis, range.start, resolved) do + current_aliases = CodeMod.Aliases.in_scope(analysis, range) + + unaliased_module + |> possible_aliases() + |> filter_by_resolution(resolved) + |> Stream.map(&build_code_action(analysis, range, current_aliases, &1)) + |> Enum.reject(&is_nil/1) + else + _ -> + [] + end + end + + @impl CodeAction.Handler + def kinds do + [:quick_fix] + end + + defp build_code_action(%Analysis{} = analysis, range, current_aliases, potential_alias_module) do + case Ast.Module.safe_split(potential_alias_module, as: :atoms) do + {:erlang, _} -> + nil + + {:elixir, segments} -> + {insert_position, trailer} = CodeMod.Aliases.insert_position(analysis, range.start) + alias_to_add = %Alias{module: segments, as: List.last(segments), explicit?: true} + replace_current_alias = get_current_replacement(analysis, range, segments) + + alias_edits = + CodeMod.Aliases.to_edits( + [alias_to_add | current_aliases], + insert_position, + trailer + ) + + changes = Changes.new(analysis.document, replace_current_alias ++ alias_edits) + + CodeAction.new( + analysis.document.uri, + "alias #{Formats.module(potential_alias_module)}", + :quick_fix, + changes + ) + end + end + + def fetch_unaliased_module(%Analysis{} = analysis, %Position{} = position, resolved) do + with {:ok, module} <- fetch_module(resolved), + %{} = aliases <- Analyzer.aliases_at(analysis, position), + false <- module in Map.values(aliases) do + {:ok, module} + else + _ -> + :error + end + end + + defp fetch_module({:module, module}), do: {:ok, module} + defp fetch_module({:struct, module}), do: {:ok, module} + defp fetch_module({:call, module, _function, _arity}), do: {:ok, module} + defp fetch_module(_), do: :error + + defp get_current_replacement(%Analysis{} = analysis, %Range{} = range, segments) do + with {:ok, patches} <- replace_full_module_on_line(analysis, range.start.line, segments), + {:ok, edits} <- Ast.patches_to_edits(analysis.document, patches) do + edits + else + _ -> + [] + end + end + + defp replace_full_module_on_line(%Analysis{} = analysis, line, segments) do + aliased_module = + segments + |> List.last() + |> List.wrap() + |> Module.concat() + |> Formats.module() + + analysis.document + |> Ast.traverse_line(line, [], fn + %Zipper{node: {:__aliases__, _, ^segments}} = zipper, patches -> + range = Sourceror.get_range(zipper.node) + + patch = %{range: range, change: aliased_module} + {zipper, [patch | patches]} + + zipper, acc -> + {zipper, acc} + end) + |> case do + {:ok, _, patches} -> {:ok, patches} + error -> error + end + end + + @similarity_threshold 0.75 + defp similar?(a, b), do: String.jaro_distance(a, b) >= @similarity_threshold + + defp filter_by_resolution(modules_stream, {:call, _module, function, _arity}) do + query_function = Atom.to_string(function) + + Stream.filter(modules_stream, fn module -> + case Modules.fetch_functions(module) do + {:ok, functions} -> + Enum.any?(functions, fn {name, _arity} -> + module_function = Atom.to_string(name) + similar?(module_function, query_function) + end) + + _ -> + false + end + end) + end + + defp filter_by_resolution(modules_stream, {:struct, _}) do + Stream.filter(modules_stream, fn module -> + case Modules.fetch_functions(module) do + {:ok, functions} -> Keyword.has_key?(functions, :__struct__) + _ -> false + end + end) + end + + defp filter_by_resolution(modules_stream, _) do + modules_stream + end + + def possible_aliases(unaliased_module) do + module_subject = Formats.module(unaliased_module) + + case Ast.Module.safe_split(unaliased_module) do + {:elixir, unaliased_strings} -> + module_subject + |> do_fuzzy_search() + |> Stream.filter(fn module -> + {:elixir, split} = Ast.Module.safe_split(module) + alias_as = List.last(split) + subject_module = module + RemoteControl.Module.Loader.ensure_loaded(subject_module) + + protocol_or_implementation? = function_exported?(module, :__impl__, 1) + + not protocol_or_implementation? and + Enum.any?(unaliased_strings, &similar?(&1, alias_as)) + end) + + _ -> + [] + end + end + + defp do_fuzzy_search(subject) do + # Note: we can't use the indexer's fuzzy matcher here, since it + # ignores all deps, and then we won't be able to alias any deps module + + for {mod, _, _} <- all_modules(), + elixir_module?(mod), + not Namespace.Module.prefixed?(mod) do + module_name = List.to_atom(mod) + + %Entry{ + id: module_name, + path: "", + subject: module_name, + subtype: :definition, + type: :module + } + end + |> Fuzzy.from_entries() + |> Fuzzy.match(subject) + end + + defp all_modules do + # Note: this is for testing + :code.all_available() + end + + defp elixir_module?([?E, ?l, ?i, ?x, ?i, ?r, ?. | _]), do: true + defp elixir_module?(_), do: false +end diff --git a/engine/lib/engine/code_action/handlers/organize_aliases.ex b/engine/lib/engine/code_action/handlers/organize_aliases.ex new file mode 100644 index 00000000..01638ba1 --- /dev/null +++ b/engine/lib/engine/code_action/handlers/organize_aliases.ex @@ -0,0 +1,45 @@ +defmodule Lexical.RemoteControl.CodeAction.Handlers.OrganizeAliases do + alias Lexical.Ast.Analysis + alias Lexical.Ast.Analysis.Scope + alias Lexical.Document + alias Lexical.Document.Changes + alias Lexical.Document.Range + alias Lexical.RemoteControl.CodeAction + alias Lexical.RemoteControl.CodeMod + + require Logger + + @behaviour CodeAction.Handler + + @impl CodeAction.Handler + def actions(%Document{} = doc, %Range{} = range, _diagnostics) do + with {:ok, _doc, analysis} <- Document.Store.fetch(doc.uri, :analysis), + :ok <- check_aliases(doc, analysis, range) do + aliases = CodeMod.Aliases.in_scope(analysis, range) + {insert_position, trailer} = CodeMod.Aliases.insert_position(analysis, range.start) + edits = CodeMod.Aliases.to_edits(aliases, insert_position, trailer) + + if Enum.empty?(edits) do + [] + else + changes = Changes.new(doc, edits) + [CodeAction.new(doc.uri, "Organize aliases", :source_organize_imports, changes)] + end + else + _ -> + [] + end + end + + @impl CodeAction.Handler + def kinds do + [:source, :source_organize_imports] + end + + defp check_aliases(%Document{}, %Analysis{} = analysis, %Range{} = range) do + case Analysis.module_scope(analysis, range) do + %Scope{aliases: [_ | _]} -> :ok + _ -> :error + end + end +end diff --git a/engine/lib/engine/code_action/handlers/remove_unused_alias.ex b/engine/lib/engine/code_action/handlers/remove_unused_alias.ex new file mode 100644 index 00000000..2dfa432f --- /dev/null +++ b/engine/lib/engine/code_action/handlers/remove_unused_alias.ex @@ -0,0 +1,245 @@ +defmodule Lexical.RemoteControl.CodeAction.Handlers.RemoveUnusedAlias do + @moduledoc """ + A code action that removes an unused alias + + Most of the code actions are fairly straightforward, but I think this one deserves a couple of comments on + the approach. I initially tried the following: + + * Finding the alias via Sourceror's Zipper.find + * Rewriting the ast via Macro.prewalk / postwalk + * Using Macro.travesrse where I'd mark the metadata as being deleted in the prewalker, and + delete it in the postwalker. + + They had the following problems. + Sourceror would consistently produce ast that was not recognized by elixir 1.14's code normalizer, causing a crash. + Using AST rewriting was susceptible to infinite recursion, and it was extremely difficult to delete blocks reliably. + Blocks in one context would be deleted, but with a different formulation, nils would appear in the output code. + It was also very difficult to pop up the stack and delete an entire multiple alias without zippers. + + So the approach we have here utilizes a hybrid of AST walking / text replacement. It works for all the examples + I could come up with, but it's a bit longer than I desired. Dorgan said he'd take a look at the errors in the + normalizer and possibly fix sourceror, so until then, this is what we have. + """ + + alias Lexical.Ast + alias Lexical.Ast.Analysis + alias Lexical.Document + alias Lexical.Document.Changes + alias Lexical.Document.Edit + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.RemoteControl.Analyzer + alias Lexical.RemoteControl.CodeAction + alias Lexical.RemoteControl.CodeAction.Diagnostic + alias Sourceror.Zipper + + import Record + + defrecordp :multi_alias_metadata, [ + :document, + :multi_alias_range, + :removed_alias_range, + :alias_count + ] + + defrecordp :single_alias_metadata, [:document, :range] + @behaviour CodeAction.Handler + + @impl CodeAction.Handler + def actions(%Document{} = document, %Range{} = range, diagnostics) do + Enum.reduce(diagnostics, [], fn %Diagnostic{} = diagnostic, acc -> + case to_edit(document, range.start, diagnostic) do + {:ok, module_name, edit} -> + changes = Changes.new(document, [edit]) + action = CodeAction.new(document.uri, "Remove alias #{module_name}", :source, changes) + + [action | acc] + + _ -> + acc + end + end) + end + + @impl CodeAction.Handler + def kinds do + [:source] + end + + defp to_edit(%Document{} = document, %Position{} = position, %Diagnostic{} = diagnostic) do + with {:ok, module_string} <- fetch_unused_alias_module_string(diagnostic), + {:ok, _doc, %Analysis{} = analysis} <- Document.Store.fetch(document.uri, :analysis), + last_segment = String.to_atom(module_string), + {:ok, full_alias} <- fetch_full_alias(analysis, position, last_segment), + {:ok, alias_meta} <- fetch_alias_metadata(position, analysis, full_alias, last_segment), + {:ok, edit} <- fetch_edit(alias_meta) do + {:ok, module_string, edit} + else + _ -> + :error + end + end + + @alias_regex ~r/unused alias (\w+)/ + defp fetch_unused_alias_module_string(%Diagnostic{} = diagnostic) do + case Regex.scan(@alias_regex, diagnostic.message) do + [[_, module_string]] -> {:ok, module_string} + _ -> :error + end + end + + defp fetch_alias_metadata( + %Position{} = cursor, + %Analysis{} = analysis, + full_alias, + last_segment + ) do + zipper = Zipper.zip(analysis.ast) + document = analysis.document + + with :error <- find_single_alias(document, cursor, zipper, full_alias, last_segment) do + find_multi_alias(document, cursor, zipper, last_segment) + end + end + + defp find_single_alias( + %Document{} = document, + %Position{} = cursor, + %Zipper{} = zipper, + full_alias, + last_segment + ) do + finder = fn + {:alias, _, [{:__aliases__, _, ^full_alias}]} = node -> + Ast.contains_position?(node, cursor) + + {:alias, _, + [ + {:__aliases__, _, ^full_alias}, + [{{:__block__, _, [:as]}, {:__aliases__, _, [^last_segment]}}] + ]} = node -> + Ast.contains_position?(node, cursor) + + _ -> + false + end + + case Zipper.find(zipper, finder) do + nil -> + :error + + %Zipper{node: node} -> + metadata = + single_alias_metadata(document: document, range: Ast.Range.fetch!(node, document)) + + {:ok, metadata} + end + end + + defp find_multi_alias( + %Document{} = document, + %Position{} = cursor, + %Zipper{} = zipper, + last_segment + ) do + finder = fn + {:alias, _, [{{:., _, _}, _, multi_alias_list}]} = node -> + Enum.find_value(multi_alias_list, &segment_matches?(&1, last_segment)) and + Ast.contains_position?(node, cursor) + + _ -> + false + end + + case Zipper.find(zipper, finder) do + nil -> + :error + + %Zipper{node: {:alias, _, [{{:., _, _}, _, multi_alias_list}]}} = zipper -> + alias_node = Enum.find(multi_alias_list, &segment_matches?(&1, last_segment)) + + multi_alias = + multi_alias_metadata( + document: document, + multi_alias_range: Ast.Range.fetch!(zipper.node, document), + removed_alias_range: Ast.Range.fetch!(alias_node, document), + alias_count: length(multi_alias_list) + ) + + {:ok, multi_alias} + end + end + + defp fetch_full_alias(%Analysis{} = analysis, %Position{} = position, last_segment) do + aliases = Analyzer.aliases_at(analysis, position) + + with {:ok, aliased_module} <- Map.fetch(aliases, last_segment), + {:elixir, full_alias} <- Ast.Module.safe_split(aliased_module, as: :atoms) do + {:ok, full_alias} + end + end + + defp segment_matches?({:__aliases__, _, segments}, last_segment) do + List.last(segments) == last_segment + end + + defp segment_matches?(_, _), do: false + + defp fetch_edit(single_alias_metadata(range: %Range{} = range)) do + updated_range = + range + |> put_in([:start, :character], 1) + |> include_next_line() + + {:ok, Edit.new("", updated_range)} + end + + defp fetch_edit(multi_alias_metadata(alias_count: 1, multi_alias_range: range)) do + # we're removing the last alias, so we can remove the entire thing. + {:ok, Edit.new("", range)} + end + + defp fetch_edit( + multi_alias_metadata( + document: %Document{} = document, + removed_alias_range: %Range{} = range + ) + ) do + current_line = line_text(document, range.start.line) + previous_line = line_text(document, range.start.line - 1) + + {range, edit_text} = + if not String.ends_with?(current_line, ",") and String.ends_with?(previous_line, ",") do + # delete the previous line's comma + range = %Range{ + range + | start: Position.new(document, range.start.line - 1, String.length(previous_line)) + } + + {range, "\n"} + else + {put_in(range.start.character, 1), ""} + end + + {:ok, Edit.new(edit_text, include_next_line(range))} + end + + defp fetch_edit(_), do: :error + + defp line_text(%Document{} = document, line_number) do + case Document.fetch_text_at(document, line_number) do + {:ok, line_text} -> line_text + _ -> "" + end + end + + defp include_next_line(%Range{} = range) do + update_in(range.end, fn old_position -> + %Position{ + old_position + | line: old_position.line + 1, + character: 1 + } + end) + end +end diff --git a/engine/lib/engine/code_action/handlers/replace_remote_function.ex b/engine/lib/engine/code_action/handlers/replace_remote_function.ex new file mode 100644 index 00000000..d7062bc5 --- /dev/null +++ b/engine/lib/engine/code_action/handlers/replace_remote_function.ex @@ -0,0 +1,146 @@ +defmodule Lexical.RemoteControl.CodeAction.Handlers.ReplaceRemoteFunction do + alias Lexical.Ast + alias Lexical.Document + alias Lexical.Document.Changes + alias Lexical.Document.Edit + alias Lexical.Document.Range + alias Lexical.RemoteControl + alias Lexical.RemoteControl.CodeAction + alias Lexical.RemoteControl.CodeAction.Diagnostic + alias Lexical.RemoteControl.Modules + alias Sourceror.Zipper + + @behaviour CodeAction.Handler + + @impl CodeAction.Handler + def actions(%Document{} = doc, %Range{}, diagnostics) do + Enum.flat_map(diagnostics, fn %Diagnostic{} = diagnostic -> + with {:ok, module, function, arity, line_number} <- extract_function_and_line(diagnostic), + {:ok, suggestions} <- prepare_suggestions(module, function, arity) do + to_code_actions(doc, line_number, module, function, suggestions) + else + _ -> + [] + end + end) + end + + @impl CodeAction.Handler + def kinds do + [:quick_fix] + end + + @spec to_code_actions(Document.t(), non_neg_integer(), module(), String.t(), [atom()]) :: + [CodeAction.t()] + defp to_code_actions(%Document{} = doc, line_number, module, function, suggestions) do + suggestions + |> Enum.reduce([], fn suggestion, acc -> + case apply_transform(doc, line_number, module, function, suggestion) do + {:ok, edits} -> + changes = Changes.new(doc, edits) + code_action = CodeAction.new(doc.uri, "Rename to #{suggestion}", :quick_fix, changes) + + [code_action | acc] + + :error -> + acc + end + end) + |> Enum.reverse() + end + + @spec apply_transform(Document.t(), non_neg_integer(), module(), String.t(), atom()) :: + {:ok, [Edit.t()]} | :error + defp apply_transform(%Document{} = doc, line_number, module, function, suggestion) do + {:ok, doc, analysis} = Document.Store.fetch(doc.uri, :analysis) + function_atom = String.to_atom(function) + position = Document.Position.new(doc, line_number, 0) + + doc + |> Ast.traverse_line(line_number, [], fn + %Zipper{node: {{:., _, [{:__aliases__, _, module_alias}, ^function_atom]}, _, _}} = zipper, + patches -> + case RemoteControl.Analyzer.expand_alias(module_alias, analysis, position) do + {:ok, ^module} -> + patch = Sourceror.Patch.rename_call(zipper.node, suggestion) + {zipper, [patch | patches]} + + _ -> + {zipper, patches} + end + + %Zipper{node: {{:., _, [{:__block__, _, [^module]}, ^function_atom]}, _, _}} = zipper, + patches -> + # this is an erlang call :ets.insert(...) + patch = Sourceror.Patch.rename_call(zipper.node, suggestion) + + {zipper, [patch | patches]} + + zipper, patches -> + {zipper, patches} + end) + |> case do + {:ok, _zipper, patches} -> + Ast.patches_to_edits(doc, patches) + + _ -> + :error + end + end + + defp extract_function_and_line(%Diagnostic{} = diagnostic) do + with {:ok, module, function, arity} <- extract_function(diagnostic.message) do + {:ok, module, function, arity, diagnostic.range.start.line} + end + end + + @function_re ~r/(warning: |function )?([^\/]+)\/(.*) is undefined or private. Did you mean:.*/ + defp extract_function(message) do + result = + with [[_, _, module_and_function, arity]] <- Regex.scan(@function_re, message), + {:ok, module, function_name} <- separate_module_from_function(module_and_function) do + {:ok, module, function_name, String.to_integer(arity)} + end + + result + end + + defp separate_module_from_function(module_and_function) do + module_and_function + |> String.split(".") + |> List.pop_at(-1) + |> case do + {function_name, [_ | _] = module_alias} -> + {:ok, alias_to_module(module_alias), function_name} + + _ -> + :error + end + end + + defp alias_to_module([":" <> erlang_alias]) do + String.to_atom(erlang_alias) + end + + defp alias_to_module(module_alias) do + Module.concat(module_alias) + end + + @function_threshold 0.77 + @max_suggestions 5 + defp prepare_suggestions(module, function, arity) do + with {:ok, module_functions} <- Modules.fetch_functions(module) do + suggestions = + for {module_function, ^arity} <- module_functions, + distance = module_function |> Atom.to_string() |> String.jaro_distance(function), + distance >= @function_threshold do + {distance, module_function} + end + |> Enum.sort(:desc) + |> Enum.take(@max_suggestions) + |> Enum.map(fn {_distance, module_function} -> module_function end) + + {:ok, suggestions} + end + end +end diff --git a/engine/lib/engine/code_action/handlers/replace_with_underscore.ex b/engine/lib/engine/code_action/handlers/replace_with_underscore.ex new file mode 100644 index 00000000..620d0604 --- /dev/null +++ b/engine/lib/engine/code_action/handlers/replace_with_underscore.ex @@ -0,0 +1,83 @@ +defmodule Lexical.RemoteControl.CodeAction.Handlers.ReplaceWithUnderscore do + alias Lexical.Ast + alias Lexical.Document + alias Lexical.Document.Changes + alias Lexical.Document.Range + alias Lexical.RemoteControl.CodeAction + alias Lexical.RemoteControl.CodeAction.Diagnostic + alias Sourceror.Zipper + + @behaviour CodeAction.Handler + + @impl CodeAction.Handler + def actions(%Document{} = doc, %Range{}, diagnostics) do + Enum.reduce(diagnostics, [], fn %Diagnostic{} = diagnostic, acc -> + with {:ok, variable_name, line_number} <- extract_variable_and_line(diagnostic), + {:ok, changes} <- to_changes(doc, line_number, variable_name) do + action = CodeAction.new(doc.uri, "Rename to _#{variable_name}", :quick_fix, changes) + + [action | acc] + else + _ -> + acc + end + end) + end + + @impl CodeAction.Handler + def kinds do + [:quick_fix] + end + + @spec to_changes(Document.t(), non_neg_integer(), String.t() | atom) :: + {:ok, Changes.t()} | :error + defp to_changes(%Document{} = document, line_number, variable_name) do + case apply_transform(document, line_number, variable_name) do + {:ok, edits} -> + {:ok, Changes.new(document, edits)} + + error -> + error + end + end + + defp apply_transform(document, line_number, unused_variable_name) do + underscored_variable_name = :"_#{unused_variable_name}" + + result = + Ast.traverse_line(document, line_number, [], fn + %Zipper{node: {^unused_variable_name, _meta, nil} = node} = zipper, patches -> + patch = Sourceror.Patch.rename_identifier(node, underscored_variable_name) + {zipper, [patch | patches]} + + zipper, acc -> + {zipper, acc} + end) + + with {:ok, _, patches} <- result do + Ast.patches_to_edits(document, patches) + end + end + + defp extract_variable_and_line(%Diagnostic{} = diagnostic) do + with {:ok, variable_name} <- extract_variable_name(diagnostic.message), + {:ok, line} <- extract_line(diagnostic) do + {:ok, variable_name, line} + end + end + + @variable_re ~r/variable "([^"]+)" is unused/ + defp extract_variable_name(message) do + case Regex.scan(@variable_re, message) do + [[_, variable_name]] -> + {:ok, String.to_atom(variable_name)} + + _ -> + {:error, {:no_variable, message}} + end + end + + defp extract_line(%Diagnostic{} = diagnostic) do + {:ok, diagnostic.range.start.line} + end +end diff --git a/engine/lib/engine/code_intelligence/definition.ex b/engine/lib/engine/code_intelligence/definition.ex new file mode 100644 index 00000000..b854f00b --- /dev/null +++ b/engine/lib/engine/code_intelligence/definition.ex @@ -0,0 +1,183 @@ +defmodule Lexical.RemoteControl.CodeIntelligence.Definition do + alias ElixirSense.Providers.Location, as: ElixirSenseLocation + alias Future.Code + alias Lexical.Ast + alias Lexical.Ast.Analysis + alias Lexical.Document + alias Lexical.Document.Location + alias Lexical.Document.Position + alias Lexical.Formats + alias Lexical.RemoteControl.CodeIntelligence.Entity + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Store + alias Lexical.Text + + require Logger + + @spec definition(Document.t(), Position.t()) :: {:ok, [Location.t()]} | {:error, String.t()} + def definition(%Document{} = document, %Position{} = position) do + with {:ok, _, analysis} <- Document.Store.fetch(document.uri, :analysis), + {:ok, entity, _range} <- Entity.resolve(analysis, position) do + fetch_definition(entity, analysis, position) + end + end + + defp fetch_definition({type, entity} = resolved, %Analysis{} = analysis, %Position{} = position) + when type in [:struct, :module] do + module = Formats.module(entity) + + locations = + case Store.exact(module, type: type, subtype: :definition) do + {:ok, entries} -> + for entry <- entries, + result = to_location(entry), + match?({:ok, _}, result) do + {:ok, location} = result + location + end + + _ -> + [] + end + + maybe_fallback_to_elixir_sense(resolved, locations, analysis, position) + end + + defp fetch_definition( + {:call, module, function, arity} = resolved, + %Analysis{} = analysis, + %Position{} = position + ) do + mfa = Formats.mfa(module, function, arity) + + definitions = + mfa + |> query_search_index(subtype: :definition) + |> Stream.flat_map(fn entry -> + case entry do + %Entry{type: {:function, :delegate}} -> + mfa = get_in(entry, [:metadata, :original_mfa]) + query_search_index(mfa, subtype: :definition) ++ [entry] + + _ -> + [entry] + end + end) + |> Stream.uniq_by(& &1.subject) + + locations = + for entry <- definitions, + result = to_location(entry), + match?({:ok, _}, result) do + {:ok, location} = result + location + end + + maybe_fallback_to_elixir_sense(resolved, locations, analysis, position) + end + + defp fetch_definition(_, %Analysis{} = analysis, %Position{} = position) do + elixir_sense_definition(analysis, position) + end + + defp maybe_fallback_to_elixir_sense(resolved, locations, analysis, position) do + case locations do + [] -> + Logger.info("No definition found for #{inspect(resolved)} with Indexer.") + + elixir_sense_definition(analysis, position) + + [location] -> + {:ok, location} + + _ -> + {:ok, locations} + end + end + + defp elixir_sense_definition(%Analysis{} = analysis, %Position{} = position) do + analysis.document + |> Document.to_string() + |> ElixirSense.definition(position.line, position.character) + |> parse_location(analysis.document) + end + + defp parse_location(%ElixirSenseLocation{} = location, document) do + %{file: file, line: line, column: column, type: type} = location + file_path = file || document.path + uri = Document.Path.ensure_uri(file_path) + + with {:ok, document} <- Document.Store.open_temporary(uri), + {:ok, text} <- Document.fetch_text_at(document, line) do + {line, column} = maybe_move_cursor_to_next_token(type, document, line, column) + range = to_precise_range(document, text, line, column) + {:ok, Location.new(range, document)} + else + _ -> + {:error, "Could not open source file or fetch line text: #{inspect(file_path)}"} + end + end + + defp parse_location(nil, _) do + {:ok, nil} + end + + defp maybe_move_cursor_to_next_token(type, document, line, column) + when type in [:function, :module, :macro] do + position = Position.new(document, line, column) + + with {:ok, zipper} <- Ast.zipper_at(document, position), + %{node: {entity_name, meta, _}} <- Sourceror.Zipper.next(zipper) do + meta = + if entity_name == :when do + %{node: {_entity_name, meta, _}} = Sourceror.Zipper.next(zipper) + meta + else + meta + end + + {meta[:line], meta[:column]} + else + _ -> + {line, column} + end + end + + defp maybe_move_cursor_to_next_token(_, _, line, column), do: {line, column} + + defp to_precise_range(%Document{} = document, text, line, column) do + case Code.Fragment.surround_context(text, {line, column}) do + %{begin: start_pos, end: end_pos} -> + Entity.to_range(document, start_pos, end_pos) + + _ -> + # If the column is 1, but the code doesn't start on the first column, which isn't what we want. + # The cursor will be placed to the left of the actual definition. + column = if column == 1, do: Text.count_leading_spaces(text) + 1, else: column + pos = {line, column} + Entity.to_range(document, pos, pos) + end + end + + defp to_location(entry) do + uri = Document.Path.ensure_uri(entry.path) + + case Document.Store.open_temporary(uri) do + {:ok, document} -> + {:ok, Location.new(entry.range, document)} + + _ -> + :error + end + end + + defp query_search_index(subject, condition) do + case Store.exact(subject, condition) do + {:ok, entries} -> + entries + + _ -> + [] + end + end +end diff --git a/engine/lib/engine/code_intelligence/docs.ex b/engine/lib/engine/code_intelligence/docs.ex new file mode 100644 index 00000000..5fa5da56 --- /dev/null +++ b/engine/lib/engine/code_intelligence/docs.ex @@ -0,0 +1,96 @@ +defmodule Lexical.RemoteControl.CodeIntelligence.Docs do + @moduledoc """ + Utilities for fetching documentation for a compiled module. + """ + + alias Lexical.RemoteControl.CodeIntelligence.Docs.Entry + alias Lexical.RemoteControl.Modules + + defstruct [:module, :doc, functions_and_macros: [], callbacks: [], types: []] + + @type t :: %__MODULE__{ + module: module(), + doc: Entry.content(), + functions_and_macros: %{optional(atom()) => [Entry.t(:function | :macro)]}, + callbacks: %{optional(atom()) => [Entry.t(:callback)]}, + types: %{optional(atom()) => [Entry.t(:type)]} + } + + @doc """ + Fetches known documentation for the given module. + + ## Options + + * `:exclude_hidden` - if `true`, returns `{:error, :hidden}` for + modules that have been marked as hidden using `@moduledoc false`. + Defaults to `false`. + + """ + @spec for_module(module(), [opt]) :: {:ok, t} | {:error, any()} + when opt: {:exclude_hidden, boolean()} + def for_module(module, opts) when is_atom(module) do + exclude_hidden? = Keyword.get(opts, :exclude_hidden, false) + + with {:ok, beam} <- Modules.ensure_beam(module), + {:ok, docs} <- parse_docs(module, beam) do + if docs.doc == :hidden and exclude_hidden? do + {:error, :hidden} + else + {:ok, docs} + end + end + end + + defp parse_docs(module, beam) do + case Modules.fetch_docs(beam) do + {:ok, {:docs_v1, _anno, _lang, _format, module_doc, _meta, entries}} -> + entries_by_kind = Enum.group_by(entries, &doc_kind/1) + function_entries = Map.get(entries_by_kind, :function, []) + macro_entries = Map.get(entries_by_kind, :macro, []) + callback_entries = Map.get(entries_by_kind, :callback, []) + type_entries = Map.get(entries_by_kind, :type, []) + + spec_defs = beam |> Modules.fetch_specs() |> ok_or([]) + callback_defs = beam |> Modules.fetch_callbacks() |> ok_or([]) + type_defs = beam |> Modules.fetch_types() |> ok_or([]) + + result = %__MODULE__{ + module: module, + doc: Entry.parse_doc(module_doc), + functions_and_macros: + parse_entries(module, function_entries ++ macro_entries, spec_defs), + callbacks: parse_entries(module, callback_entries, callback_defs), + types: parse_entries(module, type_entries, type_defs) + } + + {:ok, result} + + _ -> + {:error, :no_docs} + end + end + + defp doc_kind({{kind, _name, _arity}, _anno, _sig, _doc, _meta}) do + kind + end + + defp parse_entries(module, raw_entries, defs) do + defs_by_name_arity = + Enum.group_by( + defs, + fn {name, arity, _formatted, _quoted} -> {name, arity} end, + fn {_name, _arity, formatted, _quoted} -> formatted end + ) + + raw_entries + |> Enum.map(fn raw_entry -> + entry = Entry.from_docs_v1(module, raw_entry) + defs = Map.get(defs_by_name_arity, {entry.name, entry.arity}, []) + %Entry{entry | defs: defs} + end) + |> Enum.group_by(& &1.name) + end + + defp ok_or({:ok, value}, _default), do: value + defp ok_or(_, default), do: default +end diff --git a/engine/lib/engine/code_intelligence/docs/entry.ex b/engine/lib/engine/code_intelligence/docs/entry.ex new file mode 100644 index 00000000..098af162 --- /dev/null +++ b/engine/lib/engine/code_intelligence/docs/entry.ex @@ -0,0 +1,56 @@ +defmodule Lexical.RemoteControl.CodeIntelligence.Docs.Entry do + @moduledoc """ + A documentation entry for a named entity within a module. + """ + + defstruct [ + :module, + :kind, + :name, + :arity, + :signature, + :doc, + :metadata, + defs: [] + ] + + @type t(kind) :: %__MODULE__{ + module: module(), + kind: kind, + name: atom(), + arity: arity(), + signature: [String.t()], + doc: content(), + metadata: metadata(), + defs: [String.t()] + } + + @type content :: String.t() | :none | :hidden + + @type metadata :: %{ + optional(:defaults) => pos_integer(), + optional(:since) => String.t(), + optional(:guard) => boolean(), + optional(:opaque) => boolean(), + optional(:deprecated) => boolean() + } + + @known_metadata [:defaults, :since, :guard, :opaque, :deprecated] + + @doc false + def from_docs_v1(module, {{kind, name, arity}, _anno, signature, doc, meta}) do + %__MODULE__{ + module: module, + kind: kind, + name: name, + arity: arity, + signature: signature, + doc: parse_doc(doc), + metadata: Map.take(meta, @known_metadata) + } + end + + @doc false + def parse_doc(%{"en" => doc}), do: doc + def parse_doc(atom) when atom in [:none, :hidden], do: atom +end diff --git a/engine/lib/engine/code_intelligence/entity.ex b/engine/lib/engine/code_intelligence/entity.ex new file mode 100644 index 00000000..5f89024d --- /dev/null +++ b/engine/lib/engine/code_intelligence/entity.ex @@ -0,0 +1,539 @@ +defmodule Lexical.RemoteControl.CodeIntelligence.Entity do + alias Future.Code, as: Code + alias Lexical.Ast + alias Lexical.Ast.Analysis + alias Lexical.Document + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.Formats + alias Lexical.RemoteControl + alias Sourceror.Zipper + + require Logger + require Sourceror.Identifier + + @type maybe_module :: module() | nil + @type resolved :: + {:module, maybe_module()} + | {:struct, maybe_module()} + | {:call, maybe_module(), fun_name :: atom(), arity :: non_neg_integer()} + | {:type, maybe_module(), type_name :: atom(), arity :: non_neg_integer()} + | {:module_attribute, container_module :: maybe_module(), attribute_name :: atom()} + | {:variable, variable_name :: atom()} + + defguardp is_call(form) when Sourceror.Identifier.is_call(form) and elem(form, 0) != :. + + @doc """ + Attempts to resolve the entity at the given position in the document. + + Returns `{:ok, resolved, range}` if successful, `{:error, error}` otherwise. + """ + @spec resolve(Analysis.t(), Position.t()) :: {:ok, resolved, Range.t()} | {:error, term()} + def resolve(%Analysis{} = analysis, %Position{} = position) do + analysis = Ast.reanalyze_to(analysis, position) + + with :ok <- check_commented(analysis, position), + {:ok, surround_context} <- Ast.surround_context(analysis, position), + {:ok, resolved, {begin_pos, end_pos}} <- + resolve(surround_context, analysis, position) do + Logger.info("Resolved entity: #{inspect(resolved)}") + {:ok, resolved, to_range(analysis.document, begin_pos, end_pos)} + else + :error -> {:error, :not_found} + {:error, :surround_context} -> maybe_local_capture_func(analysis, position) + {:error, _} = error -> error + end + end + + @spec to_range(Document.t(), Code.position(), Code.position()) :: Range.t() + def to_range(%Document{} = document, {begin_line, begin_column}, {end_line, end_column}) do + Range.new( + Position.new(document, begin_line, begin_column), + Position.new(document, end_line, end_column) + ) + end + + defp check_commented(%Analysis{} = analysis, %Position{} = position) do + if Analysis.commented?(analysis, position) do + :error + else + :ok + end + end + + defp resolve(%{context: context, begin: begin_pos, end: end_pos}, analysis, position) do + resolve(context, {begin_pos, end_pos}, analysis, position) + end + + defp resolve({:alias, charlist}, node_range, analysis, position) do + resolve_alias(charlist, node_range, analysis, position) + end + + defp resolve({:alias, {:local_or_var, prefix}, charlist}, node_range, analysis, position) do + resolve_alias(prefix ++ [?.] ++ charlist, node_range, analysis, position) + end + + defp resolve({:local_or_var, ~c"__MODULE__" = chars}, node_range, analysis, position) do + resolve_alias(chars, node_range, analysis, position) + end + + defp resolve({:local_or_var, chars}, node_range, analysis, position) do + maybe_fun = List.to_atom(chars) + + case Ast.path_at(analysis, position) do + {:ok, [{^maybe_fun, _, nil} = local, {def, _, [local | _]} | _]} + when def in [:def, :defp, :defmacro, :defmacrop] -> + # This case handles resolving calls that come from zero-arg definitions in + # a module, like hovering in `def my_fun| do` + {:ok, module} = RemoteControl.Analyzer.current_module(analysis, position) + {:ok, {:call, module, maybe_fun, 0}, node_range} + + {:ok, [{^maybe_fun, _, args} | _]} -> + # imported functions + arity = + case args do + arg_list when is_list(arg_list) -> length(arg_list) + _ -> 0 + end + + case fetch_module_for_function(analysis, position, maybe_fun, arity) do + {:ok, module} -> {:ok, {:call, module, maybe_fun, arity}, node_range} + _ -> {:ok, {:variable, List.to_atom(chars)}, node_range} + end + + _ -> + {:ok, {:variable, List.to_atom(chars)}, node_range} + end + end + + defp resolve({:local_arity, chars}, node_range, analysis, position) do + current_module = current_module(analysis, position) + + with {:ok, %Zipper{node: {:/, _, [_, {:__block__, _, [arity]}]}} = zipper} <- + Ast.zipper_at(analysis.document, position), + true <- inside_capture?(zipper) do + {:ok, {:call, current_module, List.to_atom(chars), arity}, node_range} + else + _ -> + {:error, :not_found} + end + end + + defp resolve({:struct, charlist}, {{start_line, start_col}, end_pos}, analysis, position) do + # exclude the leading % from the node range so that it can be + # resolved like a normal module alias + node_range = {{start_line, start_col + 1}, end_pos} + + case resolve_alias(charlist, node_range, analysis, position) do + {:ok, {struct_or_module, struct}, range} -> {:ok, {struct_or_module, struct}, range} + :error -> {:error, :not_found} + end + end + + defp resolve({:dot, alias_node, fun_chars}, node_range, analysis, position) do + fun = List.to_atom(fun_chars) + + with {:ok, module} <- expand_alias(alias_node, analysis, position) do + case Ast.path_at(analysis, position) do + {:ok, path} -> + arity = arity_at_position(path, position) + kind = kind_of_call(path, position) + {:ok, {kind, module, fun, arity}, node_range} + + _ -> + {:ok, {:call, module, fun, 0}, node_range} + end + end + end + + defp resolve({:local_call, fun_chars}, node_range, analysis, position) do + fun = List.to_atom(fun_chars) + + with {:ok, path} <- Ast.path_at(analysis, position), + arity = arity_at_position(path, position), + {module, ^fun, ^arity} <- + RemoteControl.Analyzer.resolve_local_call(analysis, position, fun, arity) do + {:ok, {:call, module, fun, arity}, node_range} + else + _ -> + module = current_module(analysis, position) + {:ok, {:call, module, fun, 0}, node_range} + end + end + + defp resolve({:unquoted_atom, _} = context, node_range, analysis, position) do + case expand_alias(context, analysis, position) do + {:ok, module} -> {:ok, {:module, module}, node_range} + _ -> {:error, {:unsupported, context}} + end + end + + defp resolve({:module_attribute, attr_name}, node_range, analysis, position) do + current_module = current_module(analysis, position) + + {:ok, {:module_attribute, current_module, List.to_atom(attr_name)}, node_range} + end + + defp resolve(context, _node_range, _analysis, _position) do + {:error, {:unsupported, context}} + end + + defp resolve_alias(charlist, node_range, analysis, position) do + {{_line, start_column}, _} = node_range + + with false <- suffix_contains_module?(charlist, start_column, position), + {:ok, path} <- Ast.path_at(analysis, position), + :struct <- kind_of_alias(path) do + resolve_struct(charlist, node_range, analysis, position) + else + _ -> + resolve_module(charlist, node_range, analysis, position) + end + end + + defp resolve_struct(charlist, node_range, analysis, %Position{} = position) do + with {:ok, struct} <- expand_alias(charlist, analysis, position) do + {:ok, {:struct, struct}, node_range} + end + end + + # Modules on a single line, e.g. "Foo.Bar.Baz" + defp resolve_module(charlist, {{line, column}, {line, _}}, analysis, %Position{} = position) do + module_before_cursor = module_before_position(charlist, column, position) + + maybe_prepended = + module_before_cursor + |> maybe_prepend_phoenix_scope_module(analysis, position) + |> maybe_prepend_ecto_schema(analysis, position) + + with {:ok, module} <- expand_alias(maybe_prepended, analysis, position) do + end_column = column + String.length(module_before_cursor) + {:ok, {:module, module}, {{line, column}, {line, end_column}}} + end + end + + # Modules on multiple lines, e.g. "Foo.\n Bar.\n Baz" + # Since we no longer have formatting information at this point, we + # just return the entire module for now. + defp resolve_module(charlist, node_range, analysis, %Position{} = position) do + with {:ok, module} <- expand_alias(charlist, analysis, position) do + {:ok, {:module, module}, node_range} + end + end + + defp maybe_prepend_ecto_schema(module_string, %Analysis{} = analysis, %Position{} = position) do + with true <- Ecto.Schema in RemoteControl.Analyzer.uses_at(analysis, position), + true <- in_inline_embed?(analysis, position), + {:ok, parent_module} <- RemoteControl.Analyzer.current_module(analysis, position) do + parent_module + |> Module.concat(module_string) + |> Formats.module() + else + _ -> + module_string + end + end + + @embeds [:embeds_one, :embeds_many] + defp in_inline_embed?(%Analysis{} = analysis, %Position{} = position) do + case Ast.path_at(analysis, position) do + {:ok, path} -> + path + |> Zipper.zip() + |> Zipper.find(fn + {embed, meta, _} when embed in @embeds -> + Keyword.has_key?(meta, :do) + + _ -> + false + end) + |> then(&match?(%Zipper{}, &1)) + end + end + + defp maybe_prepend_phoenix_scope_module(module_string, analysis, position) do + with {:ok, scope_segments} <- fetch_phoenix_scope_alias_segments(analysis, position), + {:ok, scope_module} <- + RemoteControl.Analyzer.expand_alias(scope_segments, analysis, position), + cursor_module = Module.concat(scope_module, module_string), + true <- + phoenix_controller_module?(cursor_module) or phoenix_liveview_module?(cursor_module) do + Formats.module(cursor_module) + else + _ -> + module_string + end + end + + defp fetch_phoenix_scope_alias_segments(analysis, position) do + # fetch the alias segments from the `scope` macro + # e.g. `scope "/foo", FooWeb.Controllers` + # the alias module is `FooWeb.Controllers`, and the segments is `[:FooWeb, :Controllers]` + path = + analysis + |> Ast.cursor_path(position) + |> Enum.filter(&match?({:scope, _, [_ | _]}, &1)) + # There might be nested `scope` macros, we need the immediate ancestor + |> List.last() + + if path do + {_, paths} = + path + |> Zipper.zip() + |> Zipper.traverse([], fn + %Zipper{node: {:scope, _, [_, {:__aliases__, _, segments} | _]}} = zipper, acc -> + {zipper, [segments | acc]} + + zipper, acc -> + {zipper, acc} + end) + + {:ok, paths |> Enum.reverse() |> List.flatten()} + else + :error + end + end + + defp phoenix_controller_module?(module) do + function_exists?(module, :call, 2) and function_exists?(module, :action, 2) + end + + defp phoenix_liveview_module?(module) do + function_exists?(module, :mount, 3) and function_exists?(module, :render, 1) + end + + # Take only the segments at and before the cursor, e.g. + # Foo|.Bar.Baz -> Foo + # Foo.|Bar.Baz -> Foo.Bar + defp module_before_position(charlist, start_column, %Position{} = position) + when is_list(charlist) do + charlist + |> List.to_string() + |> module_before_position(position.character - start_column) + end + + defp module_before_position(string, index) when is_binary(string) do + {prefix, suffix} = String.split_at(string, index) + + case String.split(suffix, ".", parts: 2) do + [before_dot, _after_dot] -> prefix <> before_dot + [before_dot] -> prefix <> before_dot + end + end + + # %TopLevel|.Struct{} -> true + # %TopLevel.Str|uct{} -> false + defp suffix_contains_module?(charlist, start_column, %Position{} = position) do + charlist + |> List.to_string() + |> suffix_contains_module?(position.character - start_column) + end + + defp suffix_contains_module?(string, index) when is_binary(string) do + {_, suffix} = String.split_at(string, index) + + case String.split(suffix, ".", parts: 2) do + [_before_dot, after_dot] -> + uppercase?(after_dot) + + [_before_dot] -> + false + end + end + + defp uppercase?(after_dot) when is_binary(after_dot) do + first_char = String.at(after_dot, 0) + String.upcase(first_char) == first_char + end + + defp expand_alias({:alias, {:local_or_var, prefix}, charlist}, analysis, %Position{} = position) do + expand_alias(prefix ++ [?.] ++ charlist, analysis, position) + end + + defp expand_alias({:alias, charlist}, analysis, %Position{} = position) do + expand_alias(charlist, analysis, position) + end + + defp expand_alias({:unquoted_atom, maybe_module_charlist}, _analysis, _position) do + maybe_module = List.to_existing_atom(maybe_module_charlist) + + if function_exported?(maybe_module, :module_info, 1) do + {:ok, maybe_module} + else + :error + end + rescue + ArgumentError -> + :error + end + + defp expand_alias(charlist, analysis, %Position{} = position) when is_list(charlist) do + charlist + |> List.to_string() + |> expand_alias(analysis, position) + end + + defp expand_alias(module, analysis, %Position{} = position) when is_binary(module) do + [module] + |> Module.concat() + |> RemoteControl.Analyzer.expand_alias(analysis, position) + end + + defp expand_alias(_, _analysis, _position), do: :error + + # Pipes: + defp arity_at_position([{:|>, _, _} = pipe | _], %Position{} = position) do + {_call, _, args} = + pipe + |> Macro.unpipe() + |> Enum.find_value(fn {ast, _arg_position} -> + if Ast.contains_position?(ast, position) do + ast + end + end) + + length(args) + 1 + end + + # Calls inside of a pipe: + # |> MyModule.some_function(1, 2) + defp arity_at_position([{_, _, args} = call, {:|>, _, _} | _], _position) when is_call(call) do + length(args) + 1 + end + + # Calls as part of a capture: + # &MyModule.some_function/2 + defp arity_at_position( + [ + # To correctly identify a fun/arity capture, the zero-arg call + # should be the first argument to a `/` binary op, and that `/` + # should be the only argument to a `&` unary op. + {_, _, []} = call, + {:/, _, [call, {:__block__, _, [arity]}]} = slash, + {:&, _, [slash]} | _ + ], + _position + ) + when is_call(call) and is_integer(arity) do + arity + end + + # Calls not inside of a pipe: + # MyModule.some_function(1, 2) + # some_function.(1, 2) + defp arity_at_position([{_, _, args} = call | _], _position) when is_call(call) do + length(args) + end + + defp arity_at_position([_non_call | rest], %Position{} = position) do + arity_at_position(rest, position) + end + + defp arity_at_position([], _position), do: 0 + + # Walk up the path to see whether we're in the right-hand argument of + # a `::` type operator, which would make the kind a `:type`, not a call. + # Calls that occur on the right of a `::` type operator have kind `:type` + defp kind_of_call([{:"::", _, [_, right_arg]} | rest], %Position{} = position) do + if Ast.contains_position?(right_arg, position) do + :type + else + kind_of_call(rest, position) + end + end + + defp kind_of_call([_ | rest], %Position{} = position) do + kind_of_call(rest, position) + end + + defp kind_of_call([], _position), do: :call + + # There is a fixed set of situations where an alias is being used as + # a `:struct`, otherwise resolve as a `:module`. + defp kind_of_alias(path) + + # |%Foo{} + defp kind_of_alias([{:%, _, _}]), do: :struct + + # %|Foo{} + # %|Foo.Bar{} + # %__MODULE__.|Foo{} + defp kind_of_alias([{:__aliases__, _, _}, {:%, _, _} | _]), do: :struct + + # %|__MODULE__{} + defp kind_of_alias([{:__MODULE__, _, nil}, {:%, _, _} | _]), do: :struct + + # %Foo|{} + defp kind_of_alias([{:%{}, _, _}, {:%, _, _} | _]), do: :struct + + # %|__MODULE__.Foo{} + defp kind_of_alias([head_of_aliases, {:__aliases__, _, [head_of_aliases | _]}, {:%, _, _} | _]) do + :struct + end + + # Catch-all: + defp kind_of_alias(_), do: :module + + defp fetch_module_for_function(analysis, position, function_name, arity) do + with :error <- fetch_module_for_local_function(analysis, position, function_name, arity) do + fetch_module_for_imported_function(analysis, position, function_name, arity) + end + end + + defp fetch_module_for_imported_function(analysis, position, function_name, arity) do + analysis + |> RemoteControl.Analyzer.imports_at(position) + |> Enum.find_value({:error, :not_found}, fn + {imported_module, ^function_name, ^arity} -> + {:ok, imported_module} + + _ -> + false + end) + end + + defp fetch_module_for_local_function(analysis, position, function_name, arity) do + with {:ok, current_module} <- RemoteControl.Analyzer.current_module(analysis, position), + true <- function_exported?(current_module, function_name, arity) do + {:ok, current_module} + else + _ -> :error + end + end + + defp function_exists?(module, function, arity) do + # Wrap the `function_exported?` from `Kernel` to simplify testing. + function_exported?(module, function, arity) + end + + defp current_module(%Analysis{} = analysis, %Position{} = position) do + case RemoteControl.Analyzer.current_module(analysis, position) do + {:ok, module} -> module + _ -> nil + end + end + + defp maybe_local_capture_func(analysis, position) do + with {:ok, %Zipper{node: {:/, _, [_, {:__block__, _, _}]}} = zipper} <- + Ast.zipper_at(analysis.document, position), + true <- inside_capture?(zipper) do + {:/, _, [{local_func_name, _meta, _}, {:__block__, _, [arity]}]} = zipper.node + function_name_length = local_func_name |> to_string() |> String.length() + range = Ast.Range.fetch!(zipper.node, analysis.document) + range = put_in(range.end.character, range.start.character + function_name_length) + + current_module = current_module(analysis, position) + {:ok, {:call, current_module, local_func_name, arity}, range} + else + _ -> + {:error, :not_found} + end + end + + defp inside_capture?(zipper) do + case Zipper.up(zipper) do + %Zipper{node: {:&, _, _}} -> true + _ -> false + end + end +end diff --git a/engine/lib/engine/code_intelligence/references.ex b/engine/lib/engine/code_intelligence/references.ex new file mode 100644 index 00000000..878c6b37 --- /dev/null +++ b/engine/lib/engine/code_intelligence/references.ex @@ -0,0 +1,100 @@ +defmodule Lexical.RemoteControl.CodeIntelligence.References do + alias Lexical.Ast.Analysis + alias Lexical.Document + alias Lexical.Document.Location + alias Lexical.Document.Position + alias Lexical.RemoteControl.Analyzer + alias Lexical.RemoteControl.CodeIntelligence.Entity + alias Lexical.RemoteControl.CodeIntelligence.Variable + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Store + alias Lexical.RemoteControl.Search.Subject + + require Logger + + def references(%Analysis{} = analysis, %Position{} = position, include_definitions?) do + with {:ok, resolved, _range} <- Entity.resolve(analysis, position) do + resolved + |> maybe_rewrite_resolution(analysis, position) + |> find_references(analysis, position, include_definitions?) + end + end + + defp find_references({:module, module}, _analysis, _position, include_definitions?) do + subject = Subject.module(module) + subtype = subtype(include_definitions?) + + query(subject, type: :module, subtype: subtype) + end + + defp find_references({:struct, struct_module}, _analysis, _position, include_definitions?) do + subject = Subject.module(struct_module) + subtype = subtype(include_definitions?) + + query(subject, type: :struct, subtype: subtype) + end + + defp find_references( + {:call, module, function_name, _arity}, + _analysis, + _position, + include_definitions? + ) do + subject = Subject.mfa(module, function_name, "") + subtype = subtype(include_definitions?) + + case Store.prefix(subject, type: {:function, :_}, subtype: subtype) do + {:ok, entries} -> Enum.map(entries, &to_location/1) + _ -> [] + end + end + + defp find_references( + {:module_attribute, module, attribute_name}, + _analysis, + _position, + include_definitions? + ) do + subject = Subject.module_attribute(module, attribute_name) + subtype = subtype(include_definitions?) + + query(subject, type: :module_attribute, subtype: subtype) + end + + defp find_references({:variable, var_name}, analysis, position, include_definitions?) do + analysis + |> Variable.references(position, var_name, include_definitions?) + |> Enum.map(&to_location/1) + end + + defp find_references(resolved, _, _, _include_definitions?) do + Logger.info("Not attempting to find references for unhandled type: #{inspect(resolved)}") + :error + end + + def maybe_rewrite_resolution({:call, Kernel, :defstruct, 1}, analysis, position) do + case Analyzer.current_module(analysis, position) do + {:ok, struct_module} -> {:struct, struct_module} + orig -> orig + end + end + + def maybe_rewrite_resolution(resolution, _analysis, _position) do + resolution + end + + defp to_location(%Entry{} = entry) do + uri = Document.Path.ensure_uri(entry.path) + Location.new(entry.range, uri) + end + + defp query(subject, opts) do + case Store.exact(subject, opts) do + {:ok, entries} -> Enum.map(entries, &to_location/1) + _ -> [] + end + end + + defp subtype(true = _include_definitions?), do: :_ + defp subtype(false = _include_definitions?), do: :reference +end diff --git a/engine/lib/engine/code_intelligence/structs.ex b/engine/lib/engine/code_intelligence/structs.ex new file mode 100644 index 00000000..8ef9e238 --- /dev/null +++ b/engine/lib/engine/code_intelligence/structs.ex @@ -0,0 +1,27 @@ +defmodule Lexical.RemoteControl.CodeIntelligence.Structs do + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Module.Loader + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Store + + def for_project do + if Mix.Project.get() do + {:ok, structs_from_index()} + else + RemoteControl.Mix.in_project(fn _ -> structs_from_index() end) + end + end + + defp structs_from_index do + case Store.exact(type: :struct, subtype: :definition) do + {:ok, entries} -> + for %Entry{subject: struct_module} <- entries, + Loader.ensure_loaded?(struct_module) do + struct_module + end + + _ -> + [] + end + end +end diff --git a/engine/lib/engine/code_intelligence/symbols.ex b/engine/lib/engine/code_intelligence/symbols.ex new file mode 100644 index 00000000..2459e43e --- /dev/null +++ b/engine/lib/engine/code_intelligence/symbols.ex @@ -0,0 +1,125 @@ +defmodule Lexical.RemoteControl.CodeIntelligence.Symbols do + alias Lexical.Document + alias Lexical.Document.Range + alias Lexical.RemoteControl.CodeIntelligence.Symbols + alias Lexical.RemoteControl.Search + alias Lexical.RemoteControl.Search.Indexer + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Indexer.Extractors + + @block_types [ + :ex_unit_describe, + :ex_unit_setup, + :ex_unit_setup_all, + :ex_unit_test, + :module + ] + + @symbol_extractors [ + Extractors.FunctionDefinition, + Extractors.Module, + Extractors.ModuleAttribute, + Extractors.StructDefinition, + Extractors.ExUnit + ] + + def for_document(%Document{} = document) do + {:ok, entries} = Indexer.Source.index_document(document, @symbol_extractors) + + definitions = Enum.filter(entries, &(&1.subtype == :definition)) + to_symbols(document, definitions) + end + + def for_workspace(query) do + case Search.Store.fuzzy(query, []) do + {:ok, entries} -> + Enum.map(entries, &Symbols.Workspace.from_entry/1) + + _ -> + [] + end + end + + defp to_symbols(%Document{} = document, entries) do + entries_by_block_id = Enum.group_by(entries, & &1.block_id) + rebuild_structure(entries_by_block_id, document, :root) + end + + defp rebuild_structure(entries_by_block_id, %Document{} = document, block_id) do + block_entries = Map.get(entries_by_block_id, block_id, []) + + Enum.flat_map(block_entries, fn + %Entry{type: {:protocol, _}} = entry -> + map_block_type(document, entry, entries_by_block_id) + + %Entry{type: {:function, type}} = entry when type in [:public, :private] -> + map_block_type(document, entry, entries_by_block_id) + + %Entry{type: type, subtype: :definition} = entry when type in @block_types -> + map_block_type(document, entry, entries_by_block_id) + + %Entry{} = entry -> + case Symbols.Document.from(document, entry) do + {:ok, symbol} -> [symbol] + _ -> [] + end + end) + end + + defp map_block_type(%Document{} = document, %Entry{} = entry, entries_by_block_id) do + result = + if Map.has_key?(entries_by_block_id, entry.id) do + children = + entries_by_block_id + |> rebuild_structure(document, entry.id) + |> Enum.sort_by(&sort_by_start/1) + |> group_functions() + + Symbols.Document.from(document, entry, children) + else + Symbols.Document.from(document, entry) + end + + case result do + {:ok, symbol} -> [symbol] + _ -> [] + end + end + + defp group_functions(children) do + {functions, other} = Enum.split_with(children, &match?({:function, _}, &1.original_type)) + + grouped_functions = + functions + |> Enum.group_by(fn symbol -> + symbol.subject |> String.split(".") |> List.last() |> String.trim() + end) + |> Enum.map(fn + {_name_and_arity, [definition]} -> + definition + + {name_and_arity, [first | _] = defs} -> + last = List.last(defs) + [type, _] = String.split(first.name, " ", parts: 2) + name = "#{type} #{name_and_arity}" + + children = + Enum.map(defs, fn child -> + [_, rest] = String.split(child.name, " ", parts: 2) + %Symbols.Document{child | name: rest} + end) + + range = Range.new(first.range.start, last.range.end) + %Symbols.Document{first | name: name, range: range, children: children} + end) + + grouped_functions + |> Enum.concat(other) + |> Enum.sort_by(&sort_by_start/1) + end + + defp sort_by_start(%Symbols.Document{} = symbol) do + start = symbol.range.start + {start.line, start.character} + end +end diff --git a/engine/lib/engine/code_intelligence/symbols/document.ex b/engine/lib/engine/code_intelligence/symbols/document.ex new file mode 100644 index 00000000..8009244e --- /dev/null +++ b/engine/lib/engine/code_intelligence/symbols/document.ex @@ -0,0 +1,99 @@ +defmodule Lexical.RemoteControl.CodeIntelligence.Symbols.Document do + alias Lexical.Document + alias Lexical.Formats + alias Lexical.RemoteControl.Search.Indexer.Entry + + defstruct [:name, :type, :range, :detail_range, :detail, :original_type, :subject, children: []] + + def from(%Document{} = document, %Entry{} = entry, children \\ []) do + case name_and_type(entry.type, entry, document) do + {name, type} -> + range = entry.block_range || entry.range + + {:ok, + %__MODULE__{ + name: name, + type: type, + range: range, + detail_range: entry.range, + children: children, + original_type: entry.type, + subject: entry.subject + }} + + _ -> + :error + end + end + + @do_regex ~r/\s*do\s*$/ + + defp name_and_type({:function, type}, %Entry{} = entry, %Document{} = document) + when type in [:public, :private, :delegate] do + fragment = + document + |> Document.fragment(entry.range.start, entry.range.end) + |> remove_line_breaks_and_multiple_spaces() + + prefix = + case type do + :public -> "def " + :private -> "defp " + :delegate -> "defdelegate " + end + + {prefix <> fragment, entry.type} + end + + @ignored_attributes ~w[spec doc moduledoc derive impl tag] + @type_name_regex ~r/@type\s+[^\s]+/ + + defp name_and_type(:module_attribute, %Entry{} = entry, document) do + case String.split(entry.subject, "@") do + [_, name] when name in @ignored_attributes -> + nil + + [_, "type"] -> + type_text = Document.fragment(document, entry.range.start, entry.range.end) + + name = + case Regex.scan(@type_name_regex, type_text) do + [[match]] -> match + _ -> "@type ??" + end + + {name, :type} + + [_, name] -> + {"@#{name}", :module_attribute} + end + end + + defp name_and_type(ex_unit, %Entry{} = entry, document) + when ex_unit in [:ex_unit_describe, :ex_unit_setup, :ex_unit_test] do + name = + document + |> Document.fragment(entry.range.start, entry.range.end) + |> String.trim() + |> String.replace(@do_regex, "") + + {name, ex_unit} + end + + defp name_and_type(:struct, %Entry{} = entry, _document) do + module_name = Formats.module(entry.subject) + {"%#{module_name}{}", :struct} + end + + defp name_and_type(type, %Entry{subject: name}, _document) when is_atom(name) do + {Formats.module(name), type} + end + + defp name_and_type(type, %Entry{} = entry, _document) do + {to_string(entry.subject), type} + end + + defp remove_line_breaks_and_multiple_spaces(string) do + string |> String.split(~r/\s/) |> Enum.reject(&match?("", &1)) |> Enum.join(" ") + end +end diff --git a/engine/lib/engine/code_intelligence/symbols/workspace.ex b/engine/lib/engine/code_intelligence/symbols/workspace.ex new file mode 100644 index 00000000..a78a6679 --- /dev/null +++ b/engine/lib/engine/code_intelligence/symbols/workspace.ex @@ -0,0 +1,55 @@ +defmodule Lexical.RemoteControl.CodeIntelligence.Symbols.Workspace do + defmodule Link do + defstruct [:uri, :range, :detail_range] + + @type t :: %__MODULE__{ + uri: Lexical.uri(), + range: Lexical.Document.Range.t(), + detail_range: Lexical.Document.Range.t() + } + + def new(uri, range, detail_range \\ nil) do + %__MODULE__{uri: uri, range: range, detail_range: detail_range} + end + end + + alias Lexical.Document + alias Lexical.Formats + alias Lexical.RemoteControl.Search.Indexer.Entry + + defstruct [:name, :type, :link, container_name: nil] + + @type t :: %__MODULE__{ + container_name: String.t() | nil, + link: Link.t(), + name: String.t(), + type: atom() + } + + def from_entry(%Entry{} = entry) do + link = + entry.path + |> Document.Path.to_uri() + |> Link.new(entry.block_range, entry.range) + + name = symbol_name(entry.type, entry) + + %__MODULE__{ + name: name, + type: entry.type, + link: link + } + end + + @module_types [:struct, :module] + defp symbol_name(type, entry) when type in @module_types do + Formats.module(entry.subject) + end + + defp symbol_name({:protocol, _}, entry) do + Formats.module(entry.subject) + end + + defp symbol_name(_, entry), + do: entry.subject +end diff --git a/engine/lib/engine/code_intelligence/variable.ex b/engine/lib/engine/code_intelligence/variable.ex new file mode 100644 index 00000000..24168457 --- /dev/null +++ b/engine/lib/engine/code_intelligence/variable.ex @@ -0,0 +1,249 @@ +defmodule Lexical.RemoteControl.CodeIntelligence.Variable do + alias Lexical.Ast.Analysis + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.RemoteControl.Search.Indexer + alias Lexical.RemoteControl.Search.Indexer.Entry + + require Logger + + @extractors [Indexer.Extractors.Variable] + + @spec definition(Analysis.t(), Position.t(), atom()) :: {:ok, Entry.t()} | :error + def definition(%Analysis{} = analysis, %Position{} = position, variable_name) do + with {:ok, block_structure, entries} <- index_variables(analysis), + {:ok, %Entry{} = definition_entry} <- + do_find_definition(variable_name, block_structure, entries, position) do + {:ok, definition_entry} + else + _ -> + :error + end + end + + @spec references(Analysis.t(), Position.t(), charlist(), boolean()) :: [Range.t()] + def references( + %Analysis{} = analysis, + %Position{} = position, + variable_name, + include_definitions? \\ false + ) do + with {:ok, block_structure, entries} <- index_variables(analysis), + {:ok, %Entry{} = definition_entry} <- + do_find_definition(variable_name, block_structure, entries, position) do + references = search_for_references(entries, definition_entry, block_structure) + + entries = + if include_definitions? do + [definition_entry | references] + else + references + end + + Enum.sort_by(entries, fn %Entry{} = entry -> + {entry.range.start.line, entry.range.start.character} + end) + else + _ -> + [] + end + end + + defp index_variables(%Analysis{} = analysis) do + with {:ok, entries} <- Indexer.Quoted.index(analysis, @extractors), + {[block_structure], entries} <- Enum.split_with(entries, &(&1.type == :metadata)) do + {:ok, block_structure.subject, entries} + end + end + + defp do_find_definition(variable_name, block_structure, entries, position) do + with {:ok, entry} <- fetch_entry(entries, variable_name, position) do + search_for_definition(entries, entry, block_structure) + end + end + + defp fetch_entry(entries, variable_name, position) do + entries + |> Enum.find(fn %Entry{} = entry -> + entry.subject == variable_name and entry.type == :variable and + Range.contains?(entry.range, position) + end) + |> case do + %Entry{} = entry -> + {:ok, entry} + + _ -> + :error + end + end + + defp search_for_references(entries, %Entry{} = definition_entry, block_structure) do + block_id_to_children = block_id_to_children(block_structure) + + definition_children = Map.get(block_id_to_children, definition_entry.block_id, []) + + # The algorithm here is to first clean up the entries so they either are definitions or references to a + # variable with the given name. We sort them by their occurrence in the file, working backwards on a line, so + # definitions earlier in the line shadow definitions later in the line. + # Then we start at the definition entry, and then for each entry after that, + # if it's a definition, we mark the state as being shadowed, but reset the state if the block + # id isn't in the children of the current block id. If we're not in a child of the current block + # id, then we're no longer shadowed + # + # Note, this algorithm doesn't work when we have a block definition whose result rebinds a variable. + # For example: + # entries = [4, 5, 6] + # entries = + # if something() do + # [1 | entries] + # else + # entries + # end + # Searching for the references to the initial variable won't find anything inside the block, but + # searching for the rebound variable will. + + {entries, _, _} = + entries + |> Enum.filter(fn %Entry{} = entry -> + after_definition? = Position.compare(entry.range.start, definition_entry.range.end) == :gt + + variable_type? = entry.type == :variable + correct_subject? = entry.subject == definition_entry.subject + child_of_definition_block? = entry.block_id in definition_children + + variable_type? and correct_subject? and child_of_definition_block? and after_definition? + end) + |> Enum.sort_by(fn %Entry{} = entry -> + start = entry.range.start + {start.line, -start.character, entry.block_id} + end) + |> Enum.reduce({[], false, definition_entry.block_id}, fn + %Entry{subtype: :definition} = entry, {entries, _, _} -> + # we have a definition that's shadowing our definition entry + {entries, true, entry.block_id} + + %Entry{subtype: :reference} = entry, {entries, true, current_block_id} -> + shadowed? = entry.block_id in Map.get(block_id_to_children, current_block_id, []) + + entries = + if shadowed? do + entries + else + [entry | entries] + end + + {entries, shadowed?, entry.block_id} + + %Entry{} = entry, {entries, false, _} -> + # we're a reference and we're not being shadowed; collect it and move on. + {[entry | entries], false, entry.block_id} + end) + + entries + end + + defp search_for_definition(entries, %Entry{} = entry, block_structure) do + block_id_to_parents = collect_parents(block_structure) + block_path = Map.get(block_id_to_parents, entry.block_id) + entries_by_block_id = entries_by_block_id(entries) + + Enum.reduce_while([entry.block_id | block_path], :error, fn block_id, _ -> + block_entries = + entries_by_block_id + |> Map.get(block_id, []) + |> then(fn entries -> + # In the current block, reject all entries that come after the entry whose definition + # we're searching for. This prevents us from finding definitions who are shadowing + # our entry. For example, the definition on the left of the equals in: `param = param + 1`. + + if block_id == entry.block_id do + Enum.drop_while(entries, &(&1.id != entry.id)) + else + entries + end + end) + + case Enum.find(block_entries, &definition_of?(entry, &1)) do + %Entry{} = definition -> + {:halt, {:ok, definition}} + + nil -> + {:cont, :error} + end + end) + end + + defp definition_of?(%Entry{} = needle, %Entry{} = compare) do + compare.type == :variable and compare.subtype == :definition and + compare.subject == needle.subject + end + + defp entries_by_block_id(entries) do + entries + |> Enum.reduce(%{}, fn %Entry{} = entry, acc -> + Map.update(acc, entry.block_id, [entry], &[entry | &1]) + end) + |> Map.new(fn {block_id, entries} -> + entries = + Enum.sort_by( + entries, + fn %Entry{} = entry -> + {entry.range.start.line, -entry.range.start.character} + end, + :desc + ) + + {block_id, entries} + end) + end + + def block_id_to_parents(hierarchy) do + hierarchy + |> flatten_hierarchy() + |> Enum.reduce(%{}, fn {parent_id, child_id}, acc -> + old_parents = [parent_id | Map.get(acc, parent_id, [])] + Map.update(acc, child_id, old_parents, &Enum.concat(&1, old_parents)) + end) + |> Map.put(:root, []) + end + + def block_id_to_children(hierarchy) do + # Note: Parent ids are included in their children list in order to simplify + # checks for "is this id in one of its children" + + hierarchy + |> flatten_hierarchy() + |> Enum.reverse() + |> Enum.reduce(%{root: [:root]}, fn {parent_id, child_id}, current_mapping -> + current_children = [child_id | Map.get(current_mapping, child_id, [parent_id])] + + current_mapping + |> Map.put_new(child_id, [child_id]) + |> Map.update(parent_id, current_children, &Enum.concat(&1, current_children)) + end) + end + + def flatten_hierarchy(hierarchy) do + Enum.flat_map(hierarchy, fn + {k, v} when is_map(v) and map_size(v) > 0 -> + v + |> Map.keys() + |> Enum.map(&{k, &1}) + |> Enum.concat(flatten_hierarchy(v)) + + _ -> + [] + end) + end + + defp collect_parents(block_structure) do + do_collect_parents(block_structure, %{}, []) + end + + defp do_collect_parents(hierarchy, parent_map, path) do + Enum.reduce(hierarchy, parent_map, fn {block_id, children}, acc -> + parent_map = Map.put(acc, block_id, path) + do_collect_parents(children, parent_map, [block_id | path]) + end) + end +end diff --git a/engine/lib/engine/code_mod/aliases.ex b/engine/lib/engine/code_mod/aliases.ex new file mode 100644 index 00000000..105aed95 --- /dev/null +++ b/engine/lib/engine/code_mod/aliases.ex @@ -0,0 +1,256 @@ +defmodule Lexical.RemoteControl.CodeMod.Aliases do + alias Lexical.Ast + alias Lexical.Ast.Analysis + alias Lexical.Ast.Analysis.Alias + alias Lexical.Ast.Analysis.Scope + alias Lexical.Document + alias Lexical.Document.Edit + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.RemoteControl + alias Sourceror.Zipper + + @doc """ + Returns the aliases that are in scope at the given range. + """ + @spec in_scope(Analysis.t(), Range.t()) :: [Alias.t()] + def in_scope(%Analysis{} = analysis, %Range{} = range) do + analysis + |> Analysis.module_scope(range) + |> aliases_in_scope() + end + + @doc """ + Sorts the given aliases according to our rules + """ + @spec sort(Enumerable.t(Alias.t())) :: [Alias.t()] + def sort(aliases) do + Enum.sort_by(aliases, fn %Alias{} = scope_alias -> + Enum.map(scope_alias.module, fn elem -> elem |> to_string() |> String.downcase() end) + end) + end + + @doc """ + Returns the position in the document where aliases should be inserted + Since a document can have multiple module definitions, the cursor position is used to + determine the initial starting point. + + This function also returns a string that should be appended to the end of the + edits that are performed. + """ + @spec insert_position(Analysis.t(), Position.t()) :: {Position.t(), String.t() | nil} + def insert_position(%Analysis{} = analysis, %Position{} = cursor_position) do + range = Range.new(cursor_position, cursor_position) + current_aliases = in_scope(analysis, range) + do_insert_position(analysis, current_aliases, range) + end + + @doc """ + Turns a list of aliases into aliases into edits + """ + @spec to_edits([Alias.t()], Position.t(), trailer :: String.t() | nil) :: [Edit.t()] + + def to_edits(aliases, position, trailer \\ nil) + def to_edits([], _, _), do: [] + + def to_edits(aliases, %Position{} = insert_position, trailer) do + aliases = sort(aliases) + initial_spaces = insert_position.character - 1 + + alias_text = + aliases + # get rid of duplicate aliases + |> Enum.uniq_by(& &1.module) + |> Enum.map_join("\n", fn %Alias{} = a -> + text = + if List.last(a.module) == a.as do + "alias #{join(a.module)}" + else + "alias #{join(a.module)}, as: #{join(List.wrap(a.as))}" + end + + indent(text, initial_spaces) + end) + |> String.trim_trailing() + + zeroed = put_in(insert_position.character, 1) + new_alias_range = Range.new(zeroed, zeroed) + + alias_text = + if is_binary(trailer) do + alias_text <> trailer + else + alias_text + end + + edits = remove_old_aliases(aliases) + + edits ++ + [Edit.new(alias_text, new_alias_range)] + end + + defp aliases_in_scope(%Scope{} = scope) do + scope.aliases + |> Enum.filter(fn %Alias{} = scope_alias -> + scope_alias.explicit? and Range.contains?(scope.range, scope_alias.range.start) + end) + |> sort() + end + + defp join(module) do + Enum.join(module, ".") + end + + defp indent(text, spaces) do + String.duplicate(" ", spaces) <> text + end + + defp remove_old_aliases(aliases) do + ranges = + aliases + # Reject new aliases that don't have a range + |> Enum.reject(&is_nil(&1.range)) + # iterating back to start means we won't have prior edits + # clobber subsequent edits + |> Enum.sort_by(& &1.range.start.line, :desc) + |> Enum.uniq_by(& &1.range) + |> Enum.map(fn %Alias{} = alias -> + orig_range = alias.range + + orig_range + |> put_in([:start, :character], 1) + |> update_in([:end], fn %Position{} = pos -> + %Position{pos | character: 1, line: pos.line + 1} + end) + end) + + first_alias_index = length(ranges) - 1 + + ranges + |> Enum.with_index() + |> Enum.map(fn + {range, ^first_alias_index} -> + # add a new line where the first alias was to make space + # for the rewritten aliases + Edit.new("\n", range) + + {range, _} -> + Edit.new("", range) + end) + |> merge_adjacent_edits() + end + + defp merge_adjacent_edits([]), do: [] + defp merge_adjacent_edits([_] = edit), do: edit + + defp merge_adjacent_edits([edit | rest]) do + rest + |> Enum.reduce([edit], fn %Edit{} = current, [%Edit{} = last | rest] = edits -> + with {same_text, same_text} <- {last.text, current.text}, + {same, same} <- {to_tuple(current.range.end), to_tuple(last.range.start)} do + collapsed = put_in(current.range.end, last.range.end) + + [collapsed | rest] + else + _ -> + [current | edits] + end + end) + |> Enum.reverse() + end + + defp to_tuple(%Position{} = position) do + {position.line, position.character} + end + + defp do_insert_position(%Analysis{}, [%Alias{} | _] = aliases, _) do + first = Enum.min_by(aliases, &{&1.range.start.line, &1.range.start.character}) + {first.range.start, nil} + end + + defp do_insert_position(%Analysis{} = analysis, _, range) do + case Analysis.module_scope(analysis, range) do + %Scope{id: :global} = scope -> + {scope.range.start, "\n"} + + %Scope{} = scope -> + scope_start = scope.range.start + # we use the end position here because the start position is right after + # the do for modules, which puts it well into the line. The end position + # is before the end, which is equal to the indent of the scope. + + initial_position = + scope_start + |> put_in([:line], scope_start.line + 1) + |> put_in([:character], scope.range.end.character) + |> constrain_to_range(scope.range) + + position = + case Ast.zipper_at(analysis.document, scope_start) do + {:ok, zipper} -> + {_, position} = + Zipper.traverse(zipper, initial_position, fn + %Zipper{node: {:@, _, [{:moduledoc, _, _}]}} = zipper, _acc -> + # If we detect a moduledoc node, place the alias after it + range = Sourceror.get_range(zipper.node) + + {zipper, after_node(analysis.document, scope.range, range)} + + zipper, acc -> + {zipper, acc} + end) + + position + + _ -> + initial_position + end + + maybe_move_cursor_to_token_start(position, analysis) + end + end + + defp after_node(%Document{} = document, %Range{} = scope_range, %{ + start: start_pos, + end: end_pos + }) do + document + |> Position.new(end_pos[:line] + 1, start_pos[:column]) + |> constrain_to_range(scope_range) + end + + defp constrain_to_range(%Position{} = position, %Range{} = scope_range) do + cond do + position.line == scope_range.end.line -> + character = min(scope_range.end.character, position.character) + %Position{position | character: character} + + position.line > scope_range.end.line -> + %Position{scope_range.end | character: 1} + + true -> + position + end + end + + defp maybe_move_cursor_to_token_start(%Position{} = position, %Analysis{} = analysis) do + project = RemoteControl.get_project() + + with {:ok, env} <- Ast.Env.new(project, analysis, position), + false <- String.last(env.prefix) in [" ", ""] do + # ` en|d` -> `2` + # `en|d` -> `2` + non_empty_characters_count = env.prefix |> String.trim_leading() |> String.length() + + new_position = %Position{ + position + | character: position.character - non_empty_characters_count + } + + {new_position, "\n"} + else + _ -> + {position, "\n"} + end + end +end diff --git a/engine/lib/engine/code_mod/diff.ex b/engine/lib/engine/code_mod/diff.ex new file mode 100644 index 00000000..85a4a338 --- /dev/null +++ b/engine/lib/engine/code_mod/diff.ex @@ -0,0 +1,121 @@ +defmodule Lexical.RemoteControl.CodeMod.Diff do + alias Lexical.CodeUnit + alias Lexical.Document + alias Lexical.Document.Edit + alias Lexical.Document.Position + alias Lexical.Document.Range + + @spec diff(Document.t(), String.t()) :: [Edit.t()] + def diff(%Document{} = document, dest) when is_binary(dest) do + document + |> Document.to_string() + |> String.myers_difference(dest) + |> to_edits(document) + end + + defp to_edits(difference, %Document{} = document) do + {_, {current_line, prev_lines}} = + Enum.reduce(difference, {{starting_line(), starting_character()}, {[], []}}, fn + {diff_type, diff_string}, {position, edits} -> + apply_diff(diff_type, position, diff_string, edits, document) + end) + + [current_line | prev_lines] + |> Enum.flat_map(fn line_edits -> + line_edits + |> Enum.reduce([], &collapse/2) + |> Enum.reverse() + end) + end + + # This collapses a delete and an an insert that are adjacent to one another + # into a single insert, changing the delete to insert the text from the + # insert rather than "" + # It's a small optimization, but it was in the original + defp collapse( + %Edit{ + text: "", + range: %Range{ + end: %Position{character: same_character, line: same_line} + } + } = delete_edit, + [ + %Edit{ + text: insert_text, + range: + %Range{ + start: %Position{character: same_character, line: same_line} + } = _insert_edit + } + | rest + ] + ) + when byte_size(insert_text) > 0 do + collapsed_edit = %Edit{delete_edit | text: insert_text} + [collapsed_edit | rest] + end + + defp collapse(%Edit{} = edit, edits) do + [edit | edits] + end + + defp apply_diff(:eq, position, doc_string, edits, _document) do + advance(doc_string, position, edits) + end + + defp apply_diff(:del, {line, code_unit} = position, change, edits, document) do + {after_pos, {current_line, prev_lines}} = advance(change, position, edits) + {edit_end_line, edit_end_unit} = after_pos + + current_line = [ + edit(document, "", line, code_unit, edit_end_line, edit_end_unit) | current_line + ] + + {after_pos, {current_line, prev_lines}} + end + + defp apply_diff( + :ins, + {line, code_unit} = position, + change, + {current_line, prev_lines}, + document + ) do + current_line = [edit(document, change, line, code_unit, line, code_unit) | current_line] + {position, {current_line, prev_lines}} + end + + defp advance(<<>>, position, edits) do + {position, edits} + end + + for ending <- ["\r\n", "\r", "\n"] do + defp advance(<>, {line, _unit}, {current_line, prev_lines}) do + edits = {[], [current_line | prev_lines]} + advance(rest, {line + 1, starting_character()}, edits) + end + end + + defp advance(<>, {line, unit}, edits) when c < 128 do + advance(rest, {line, unit + 1}, edits) + end + + defp advance(<>, {line, unit}, edits) do + increment = CodeUnit.count(:utf8, <>) + advance(rest, {line, unit + increment}, edits) + end + + defp edit(document, text, start_line, start_unit, end_line, end_unit) + when is_binary(text) do + Edit.new( + text, + Range.new( + Position.new(document, start_line, start_unit), + Position.new(document, end_line, end_unit) + ) + ) + end + + defp starting_line, do: 1 + defp starting_character, do: 1 +end diff --git a/engine/lib/engine/code_mod/format.ex b/engine/lib/engine/code_mod/format.ex new file mode 100644 index 00000000..287ac5c3 --- /dev/null +++ b/engine/lib/engine/code_mod/format.ex @@ -0,0 +1,238 @@ +defmodule Lexical.RemoteControl.CodeMod.Format do + alias Lexical.Document + alias Lexical.Document.Changes + alias Lexical.Project + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Build + alias Lexical.RemoteControl.CodeMod.Diff + + require Logger + + @built_in_locals_without_parens [ + # Special forms + alias: 1, + alias: 2, + case: 2, + cond: 1, + for: :*, + import: 1, + import: 2, + quote: 1, + quote: 2, + receive: 1, + require: 1, + require: 2, + try: 1, + with: :*, + + # Kernel + def: 1, + def: 2, + defp: 1, + defp: 2, + defguard: 1, + defguardp: 1, + defmacro: 1, + defmacro: 2, + defmacrop: 1, + defmacrop: 2, + defmodule: 2, + defdelegate: 2, + defexception: 1, + defoverridable: 1, + defstruct: 1, + destructure: 2, + raise: 1, + raise: 2, + reraise: 2, + reraise: 3, + if: 2, + unless: 2, + use: 1, + use: 2, + + # Stdlib, + defrecord: 2, + defrecord: 3, + defrecordp: 2, + defrecordp: 3, + + # Testing + assert: 1, + assert: 2, + assert_in_delta: 3, + assert_in_delta: 4, + assert_raise: 2, + assert_raise: 3, + assert_receive: 1, + assert_receive: 2, + assert_receive: 3, + assert_received: 1, + assert_received: 2, + doctest: 1, + doctest: 2, + refute: 1, + refute: 2, + refute_in_delta: 3, + refute_in_delta: 4, + refute_receive: 1, + refute_receive: 2, + refute_receive: 3, + refute_received: 1, + refute_received: 2, + setup: 1, + setup: 2, + setup_all: 1, + setup_all: 2, + test: 1, + test: 2, + + # Mix config + config: 2, + config: 3, + import_config: 1 + ] + + @type formatter_function :: (String.t() -> any) | nil + + @spec edits(Document.t()) :: {:ok, Changes.t()} | {:error, any} + def edits(%Document{} = document) do + project = RemoteControl.get_project() + + with :ok <- Build.compile_document(project, document), + {:ok, formatted} <- do_format(project, document) do + edits = Diff.diff(document, formatted) + {:ok, Changes.new(document, edits)} + end + end + + defp do_format(%Project{} = project, %Document{} = document) do + project_path = Project.project_path(project) + + with :ok <- check_current_directory(document, project_path), + {:ok, formatter} <- formatter_for(project, document.path) do + document + |> Document.to_string() + |> formatter.() + end + end + + @spec formatter_for(Project.t(), String.t()) :: {:ok, formatter_function} + defp formatter_for(%Project{} = project, uri_or_path) do + path = Document.Path.ensure_path(uri_or_path) + {formatter_function, _opts} = formatter_for_file(project, path) + wrapped_formatter_function = wrap_with_try_catch(formatter_function) + {:ok, wrapped_formatter_function} + end + + defp wrap_with_try_catch(formatter_fn) do + fn code -> + try do + {:ok, formatter_fn.(code)} + rescue + e -> + {:error, e} + end + end + end + + defp check_current_directory(%Document{} = document, project_path) do + if subdirectory?(document.path, parent: project_path) do + :ok + else + message = + """ + Cannot format file #{document.path}. + It is not in the project at #{project_path} + """ + |> String.trim() + + {:error, message} + end + end + + defp subdirectory?(child, parent: parent) do + normalized_parent = Path.absname(parent) + String.starts_with?(child, normalized_parent) + end + + @doc """ + Returns `{formatter_function, opts}` for the given file. + """ + def formatter_for_file(%Project{} = project, file_path) do + fetch_formatter = fn _ -> Mix.Tasks.Format.formatter_for_file(file_path) end + + {formatter_function, opts} = + if RemoteControl.project_node?() do + case RemoteControl.Mix.in_project(project, fetch_formatter) do + {:ok, result} -> + result + + _error -> + formatter_opts = + case find_formatter_exs(project, file_path) do + {:ok, opts} -> + opts + + :error -> + Logger.warning("Could not find formatter options for file #{file_path}") + [] + end + + formatter = fn source -> + formatted_source = Code.format_string!(source, formatter_opts) + IO.iodata_to_binary([formatted_source, ?\n]) + end + + {formatter, formatter_opts} + end + else + fetch_formatter.(nil) + end + + opts = + Keyword.update( + opts, + :locals_without_parens, + @built_in_locals_without_parens, + &(@built_in_locals_without_parens ++ &1) + ) + + {formatter_function, opts} + end + + defp find_formatter_exs(%Project{} = project, file_path) do + root_dir = Project.root_path(project) + do_find_formatter_exs(root_dir, file_path) + end + + defp do_find_formatter_exs(root_path, root_path) do + formatter_exs_contents(root_path) + end + + defp do_find_formatter_exs(root_path, current_path) do + with :error <- formatter_exs_contents(current_path) do + parent = + current_path + |> Path.join("..") + |> Path.expand() + + do_find_formatter_exs(root_path, parent) + end + end + + defp formatter_exs_contents(current_path) do + formatter_exs = Path.join(current_path, ".formatter.exs") + + with true <- File.exists?(formatter_exs), + {formatter_terms, _binding} <- Code.eval_file(formatter_exs) do + Logger.info("found formatter in #{current_path}") + {:ok, formatter_terms} + else + err -> + Logger.info("No formatter found in #{current_path} error was #{inspect(err)}") + + :error + end + end +end diff --git a/engine/lib/engine/commands/reindex.ex b/engine/lib/engine/commands/reindex.ex new file mode 100644 index 00000000..610854b2 --- /dev/null +++ b/engine/lib/engine/commands/reindex.ex @@ -0,0 +1,166 @@ +defmodule Lexical.RemoteControl.Commands.Reindex do + defmodule State do + alias Lexical.Ast.Analysis + alias Lexical.Document + alias Lexical.ProcessCache + alias Lexical.RemoteControl.Search + alias Lexical.RemoteControl.Search.Indexer + + require Logger + require ProcessCache + + defstruct reindex_fun: nil, index_task: nil, pending_updates: %{} + + def new(reindex_fun) do + %__MODULE__{reindex_fun: reindex_fun} + end + + def set_task(%__MODULE__{} = state, {_, _} = task) do + %__MODULE__{state | index_task: task} + end + + def clear_task(%__MODULE__{} = state) do + %__MODULE__{state | index_task: nil} + end + + def reindex_uri(%__MODULE__{index_task: nil} = state, uri) do + case entries_for_uri(uri) do + {:ok, path, entries} -> + Search.Store.update(path, entries) + + _ -> + :ok + end + + state + end + + def reindex_uri(%__MODULE__{} = state, uri) do + case entries_for_uri(uri) do + {:ok, path, entries} -> + put_in(state.pending_updates[path], entries) + + _ -> + state + end + end + + def flush_pending_updates(%__MODULE__{} = state) do + Enum.each(state.pending_updates, fn {path, entries} -> + Search.Store.update(path, entries) + end) + + %__MODULE__{state | pending_updates: %{}} + end + + defp entries_for_uri(uri) do + with {:ok, %Document{} = document, %Analysis{} = analysis} <- + Document.Store.fetch(uri, :analysis), + {:ok, entries} <- Indexer.Quoted.index_with_cleanup(analysis) do + {:ok, document.path, entries} + else + error -> + Logger.error("Could not update index because #{inspect(error)}") + error + end + end + end + + @moduledoc """ + A simple genserver that prevents more than one reindexing job from running at the same time + """ + + alias Lexical.Document + alias Lexical.Project + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Api + alias Lexical.RemoteControl.Search + + use GenServer + import Api.Messages + + def start_link(opts) do + [reindex_fun: fun] = Keyword.validate!(opts, reindex_fun: &do_reindex/1) + GenServer.start_link(__MODULE__, fun, name: __MODULE__) + end + + def uri(uri) do + GenServer.cast(__MODULE__, {:reindex_uri, uri}) + end + + def perform do + perform(RemoteControl.get_project()) + end + + def perform(%Project{} = project) do + GenServer.call(__MODULE__, {:perform, project}) + end + + def running? do + GenServer.call(__MODULE__, :running?) + end + + @impl GenServer + def init(reindex_fun) do + Process.flag(:fullsweep_after, 5) + schedule_gc() + {:ok, State.new(reindex_fun)} + end + + @impl GenServer + def handle_call(:running?, _from, %State{index_task: index_task} = state) do + {:reply, match?({_, _}, index_task), state} + end + + def handle_call({:perform, project}, _from, %State{index_task: nil} = state) do + index_task = spawn_monitor(fn -> state.reindex_fun.(project) end) + {:reply, :ok, State.set_task(state, index_task)} + end + + def handle_call({:perform, _project}, _from, state) do + {:reply, {:error, "Already Running"}, state} + end + + @impl GenServer + def handle_cast({:reindex_uri, uri}, %State{} = state) do + {:noreply, State.reindex_uri(state, uri)} + end + + @impl GenServer + def handle_info({:DOWN, ref, :process, pid, _reason}, %State{index_task: {pid, ref}} = state) do + new_state = + state + |> State.flush_pending_updates() + |> State.clear_task() + + {:noreply, new_state} + end + + @impl GenServer + def handle_info(:gc, %State{} = state) do + :erlang.garbage_collect() + schedule_gc() + {:noreply, state} + end + + defp do_reindex(%Project{} = project) do + RemoteControl.broadcast(project_reindex_requested(project: project)) + + {elapsed_us, result} = + :timer.tc(fn -> + with {:ok, entries} <- Search.Indexer.create_index(project) do + Search.Store.replace(entries) + end + end) + + RemoteControl.broadcast( + project_reindexed(project: project, elapsed_ms: round(elapsed_us / 1000), status: :success) + ) + + result + end + + defp schedule_gc do + Process.send_after(self(), :gc, :timer.seconds(5)) + end +end diff --git a/engine/lib/engine/compilation/tracer.ex b/engine/lib/engine/compilation/tracer.ex new file mode 100644 index 00000000..e779be3d --- /dev/null +++ b/engine/lib/engine/compilation/tracer.ex @@ -0,0 +1,81 @@ +defmodule Lexical.RemoteControl.Compilation.Tracer do + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Build + alias Lexical.RemoteControl.Module.Loader + + import RemoteControl.Api.Messages + + def trace({:on_module, module_binary, _filename}, %Macro.Env{} = env) do + message = extract_module_updated(env.module, module_binary, env.file) + maybe_report_progress(env.file) + RemoteControl.broadcast(message) + :ok + end + + def trace(_event, _env) do + :ok + end + + def extract_module_updated(module, module_binary, filename) do + unless Loader.ensure_loaded?(module) do + erlang_filename = + filename + |> ensure_filename() + |> String.to_charlist() + + :code.load_binary(module, erlang_filename, module_binary) + end + + functions = module.__info__(:functions) + macros = module.__info__(:macros) + + struct = + if function_exported?(module, :__struct__, 0) do + module.__struct__() + |> Map.from_struct() + |> Enum.map(fn {k, v} -> + %{field: k, required?: !is_nil(v)} + end) + end + + module_updated( + file: filename, + functions: functions, + macros: macros, + name: module, + struct: struct + ) + end + + defp ensure_filename(:none) do + unique = System.unique_integer([:positive, :monotonic]) + Path.join(System.tmp_dir(), "file-#{unique}.ex") + end + + defp ensure_filename(filename) when is_binary(filename) do + filename + end + + defp maybe_report_progress(file) do + if Path.extname(file) == ".ex" do + file + |> progress_message() + |> RemoteControl.broadcast() + end + end + + defp progress_message(file) do + relative_path_elements = + file + |> Path.relative_to_cwd() + |> Path.split() + + base_dir = List.first(relative_path_elements) + file_name = List.last(relative_path_elements) + + message = "compiling: " <> Path.join([base_dir, "...", file_name]) + + label = Build.State.building_label(RemoteControl.get_project()) + project_progress(label: label, message: message) + end +end diff --git a/engine/lib/engine/completion.ex b/engine/lib/engine/completion.ex new file mode 100644 index 00000000..10923385 --- /dev/null +++ b/engine/lib/engine/completion.ex @@ -0,0 +1,139 @@ +defmodule Lexical.RemoteControl.Completion do + alias Lexical.Ast.Analysis + alias Lexical.Ast.Env + alias Lexical.Document + alias Lexical.Document.Position + alias Lexical.RemoteControl + alias Lexical.RemoteControl.CodeMod.Format + alias Lexical.RemoteControl.Completion.Candidate + + import Document.Line + + def elixir_sense_expand(%Env{} = env) do + {doc_string, position} = strip_struct_operator(env) + + line = position.line + character = position.character + hint = ElixirSense.Core.Source.prefix(doc_string, line, character) + + if String.trim(hint) == "" do + [] + else + {_formatter, opts} = Format.formatter_for_file(env.project, env.document.path) + locals_without_parens = Keyword.fetch!(opts, :locals_without_parens) + + for suggestion <- ElixirSense.suggestions(doc_string, line, character), + candidate = from_elixir_sense(suggestion, locals_without_parens), + candidate != nil do + candidate + end + end + end + + defp from_elixir_sense(suggestion, locals_without_parens) do + suggestion + |> Candidate.from_elixir_sense() + |> maybe_suppress_parens(locals_without_parens) + end + + defp maybe_suppress_parens(%struct{} = candidate, locals_without_parens) + when struct in [Candidate.Function, Candidate.Macro, Candidate.Typespec] do + atom_name = String.to_atom(candidate.name) + suppress_parens? = local_without_parens?(atom_name, candidate.arity, locals_without_parens) + + %{candidate | parens?: not suppress_parens?} + end + + defp maybe_suppress_parens(candidate, _), do: candidate + + defp local_without_parens?(fun, arity, locals_without_parens) do + arity > 0 and + Enum.any?(locals_without_parens, fn + {^fun, :*} -> true + {^fun, ^arity} -> true + _ -> false + end) + end + + def struct_fields(%Analysis{} = analysis, %Position{} = position) do + container_struct_module = + analysis + |> Lexical.Ast.cursor_path(position) + |> container_struct_module() + + with {:ok, struct_module} <- + RemoteControl.Analyzer.expand_alias(container_struct_module, analysis, position), + true <- function_exported?(struct_module, :__struct__, 0) do + struct_module + |> struct() + |> Map.from_struct() + |> Map.keys() + |> Enum.map(&Candidate.StructField.new(&1, struct_module)) + else + _ -> [] + end + end + + defp container_struct_module(cursor_path) do + Enum.find_value(cursor_path, fn + # current module struct: `%__MODULE__{|}` + {:%, _, [{:__MODULE__, _, _} | _]} -> [:__MODULE__] + # struct leading by current module: `%__MODULE__.Struct{|}` + {:%, _, [{:__aliases__, _, [{:__MODULE__, _, _} | tail]} | _]} -> [:__MODULE__ | tail] + # Struct leading by alias or just a aliased Struct: `%Struct{|}`, `%Project.Struct{|}` + {:%, _, [{:__aliases__, _, aliases} | _]} -> aliases + _ -> nil + end) + end + + # HACK: This fixes ElixirSense struct completions for certain cases. + # We should try removing when we update or remove ElixirSense. + defp strip_struct_operator(%Env{} = env) do + with true <- Env.in_context?(env, :struct_reference), + {:ok, completion_length} <- fetch_struct_completion_length(env) do + column = env.position.character + percent_position = column - (completion_length + 1) + + new_line_start = String.slice(env.line, 0, percent_position - 1) + new_line_end = String.slice(env.line, percent_position..-1//1) + new_line = [new_line_start, new_line_end] + new_position = Position.new(env.document, env.position.line, env.position.character - 1) + line_to_replace = env.position.line + + stripped_text = + env.document.lines + |> Enum.with_index(1) + |> Enum.reduce([], fn + {line(ending: ending), ^line_to_replace}, acc -> + [acc, new_line, ending] + + {line(text: line_text, ending: ending), _}, acc -> + [acc, line_text, ending] + end) + |> IO.iodata_to_binary() + + {stripped_text, new_position} + else + _ -> + doc_string = Document.to_string(env.document) + {doc_string, env.position} + end + end + + defp fetch_struct_completion_length(env) do + case Code.Fragment.cursor_context(env.prefix) do + {:struct, {:dot, {:alias, struct_name}, []}} -> + # add one because of the trailing period + {:ok, length(struct_name) + 1} + + {:struct, {:local_or_var, local_name}} -> + {:ok, length(local_name)} + + {:struct, struct_name} -> + {:ok, length(struct_name)} + + {:local_or_var, local_name} -> + {:ok, length(local_name)} + end + end +end diff --git a/engine/lib/engine/completion/candidate.ex b/engine/lib/engine/completion/candidate.ex new file mode 100644 index 00000000..93125200 --- /dev/null +++ b/engine/lib/engine/completion/candidate.ex @@ -0,0 +1,302 @@ +defmodule Lexical.RemoteControl.Completion.Candidate do + alias Lexical.RemoteControl.Completion.Candidate.ArgumentNames + require Logger + + defmodule Function do + @moduledoc false + defstruct [ + :argument_names, + :arity, + :name, + :origin, + :type, + :visibility, + :spec, + :summary, + :metadata, + parens?: true + ] + + def new(%{} = elixir_sense_map) do + arg_names = + case ArgumentNames.from_elixir_sense_map(elixir_sense_map) do + :error -> [] + names -> names + end + + __MODULE__ + |> struct(elixir_sense_map) + |> Map.put(:argument_names, arg_names) + end + end + + defmodule Callback do + @moduledoc false + defstruct [ + :argument_names, + :arity, + :metadata, + :name, + :origin, + :spec, + :summary, + :type, + parens?: true + ] + + def new(%{} = elixir_sense_map) do + arg_names = + case ArgumentNames.from_elixir_sense_map(elixir_sense_map) do + :error -> [] + names -> names + end + + __MODULE__ + |> struct(elixir_sense_map) + |> Map.put(:argument_names, arg_names) + end + end + + defmodule Macro do + @moduledoc false + defstruct [ + :argument_names, + :arity, + :name, + :origin, + :type, + :visibility, + :spec, + :metadata, + parens?: true + ] + + def new(%{} = elixir_sense_map) do + arg_names = + case ArgumentNames.from_elixir_sense_map(elixir_sense_map) do + :error -> [] + names -> names + end + + __MODULE__ + |> struct(elixir_sense_map) + |> Map.put(:argument_names, arg_names) + end + end + + defmodule Typespec do + @moduledoc false + defstruct [ + :argument_names, + :arity, + :doc, + :metadata, + :type, + :name, + :origin, + :signature, + :spec, + parens?: true + ] + + def new(%{} = elixir_sense_map) do + arg_names = + case ArgumentNames.from_elixir_sense_map(elixir_sense_map) do + :error -> [] + names -> names + end + + __MODULE__ + |> struct(elixir_sense_map) + |> Map.put(:argument_names, arg_names) + end + end + + defmodule Module do + @moduledoc false + defstruct [:full_name, :metadata, :name, :summary] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule Exception do + @moduledoc false + defstruct [:full_name, :metadata, :name, :summary] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule Behaviour do + @moduledoc false + defstruct [:full_name, :metadata, :name, :summary] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule Protocol do + @moduledoc false + defstruct [:full_name, :metadata, :name, :summary] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule Struct do + @moduledoc false + defstruct [:full_name, :metadata, :name, :summary] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule StructField do + @moduledoc false + defstruct [:call?, :name, :origin, :type_spec] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + + def new(name, origin) do + %__MODULE__{name: name, origin: origin, call?: false} + end + end + + defmodule MapField do + @moduledoc false + defstruct [:call?, :name] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule ModuleAttribute do + @moduledoc false + defstruct [:name] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule Variable do + @moduledoc false + defstruct [:name] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule Snippet do + @moduledoc false + defstruct [:detail, :documentation, :filter_text, :kind, :label, :priority, :snippet] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule MixTask do + defstruct [:full_name, :metadata, :name, :subtype, :summary, :type] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + defmodule BitstringOption do + defstruct [:name, :type] + + def new(%{} = elixir_sense_map) do + struct(__MODULE__, elixir_sense_map) + end + end + + def from_elixir_sense(%{type: :module, subtype: nil} = elixir_sense_map) do + Module.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :module, subtype: :alias} = elixir_sense_map) do + Module.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :module, subtype: :behaviour} = elixir_sense_map) do + Behaviour.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :module, subtype: :exception} = elixir_sense_map) do + Exception.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :module, subtype: :struct} = elixir_sense_map) do + Struct.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :module, subtype: :protocol} = elixir_sense_map) do + Protocol.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :module, subtype: :task} = elixir_sense_map) do + MixTask.new(elixir_sense_map) + end + + # elixir_sense suggests test cases as functions, which need to be filtered. + def from_elixir_sense(%{type: :function, name: "test " <> _} = _elixir_sense_map) do + nil + end + + def from_elixir_sense(%{type: :function} = elixir_sense_map) do + Function.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :macro} = elixir_sense_map) do + Macro.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :type_spec} = elixir_sense_map) do + Typespec.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :bitstring_option} = elixir_sense_map) do + BitstringOption.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :attribute} = elixir_sense_map) do + ModuleAttribute.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :generic, kind: :snippet} = elixir_sense_map) do + Snippet.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :variable} = elixir_sense_map) do + Variable.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :field, subtype: :struct_field} = elixir_sense_map) do + StructField.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :field, subtype: :map_key} = elixir_sense_map) do + MapField.new(elixir_sense_map) + end + + def from_elixir_sense(%{type: :callback} = elixir_sense_map) do + Callback.new(elixir_sense_map) + end + + def from_elixir_sense(elixir_sense_map) do + Logger.warning("Unhandled completion suggestion: #{inspect(elixir_sense_map)}") + nil + end +end diff --git a/engine/lib/engine/completion/candidate/argument_names.ex b/engine/lib/engine/completion/candidate/argument_names.ex new file mode 100644 index 00000000..6152f557 --- /dev/null +++ b/engine/lib/engine/completion/candidate/argument_names.ex @@ -0,0 +1,120 @@ +defmodule Lexical.RemoteControl.Completion.Candidate.ArgumentNames do + @moduledoc """ + Elixir sense, for whatever reason returns all the argument names when asked to do a completion on a function. + This means that the arity of the function might differ from the argument names returned. Furthermore, the + argument names have the defaults in them for some reason, which is completely unhelpful for completions. + + The functions below match the arity of the argument names to the given arity, and strip out the defaults, + rendering the results useful for completion. + """ + + alias Future.Code, as: Code + + @type argument_names :: [String.t()] + @default_specifier ~S(\\) + + @spec from_elixir_sense_map(map()) :: :error | argument_names() + def from_elixir_sense_map(%{args_list: argument_names, arity: arity}) do + from_elixir_sense(argument_names, arity) + end + + def from_elixir_sense_map(%{}) do + :error + end + + @spec from_elixir_sense([String.t()], non_neg_integer) :: :error | argument_names() + def from_elixir_sense(argument_names, arity) when is_list(argument_names) do + {names, required_count} = preprocess(argument_names) + + cond do + length(argument_names) < arity -> + :error + + arity < required_count -> + :error + + true -> + generate_argument_list(names, required_count, arity) + end + end + + defp generate_argument_list(names, required_count, arity) do + optional_count = arity - required_count + + {arg_list, _} = + Enum.reduce(names, {[], optional_count}, fn + {:required, arg_name}, {arg_list, optional_count} -> + {[arg_name | arg_list], optional_count} + + {:optional, _}, {_arg_list, 0} = acc -> + acc + + {:optional, arg_name}, {arg_list, optional_count} -> + {[arg_name | arg_list], optional_count - 1} + end) + + Enum.reverse(arg_list) + end + + defp split_on_default(argument) do + argument + |> String.split(@default_specifier) + |> Enum.map(&String.trim/1) + end + + @spec preprocess(argument_names()) :: {[String.t()], non_neg_integer()} + defp preprocess(argument_names) do + {names, required_count} = + argument_names + |> Enum.with_index(1) + |> Enum.reduce({[], 0}, fn {argument, index}, {names, required_count} -> + {name, increment} = + case split_on_default(argument) do + [argument_name] -> + {{:required, extract_name(argument_name, index)}, 1} + + [argument_name, _default] -> + {{:optional, extract_name(argument_name, index)}, 0} + end + + {[name | names], required_count + increment} + end) + + {Enum.reverse(names), required_count} + end + + defp extract_name(argument, index) do + case Code.Fragment.cursor_context(argument) do + {:unquoted_atom, atom} -> + ":#{atom}" + + {:local_or_var, name} -> + List.to_string(name) + + :none -> + argument + |> String.split("=") + |> find_local_in_pattern_match(index) + + _ -> + argument + end + end + + defp find_local_in_pattern_match([], index) do + "arg_#{index}" + end + + defp find_local_in_pattern_match([first | rest], index) do + case Code.Fragment.cursor_context(first) do + {:local_or_var, name} -> + List.to_string(name) + + {:local_call, name} -> + List.to_string(name) + + _ -> + find_local_in_pattern_match(rest, index) + end + end +end diff --git a/engine/lib/engine/dispatch.ex b/engine/lib/engine/dispatch.ex new file mode 100644 index 00000000..9cc3b3e8 --- /dev/null +++ b/engine/lib/engine/dispatch.ex @@ -0,0 +1,84 @@ +defmodule Lexical.RemoteControl.Dispatch do + @moduledoc """ + A global event dispatcher for lexical. + + Dispatch allows two recipients of its messages, processes and modules. A process must register + itself via a call to `register_listener`, while a process must implement the + `Lexical.RemoteControl.Dispatch.Handler` behaviour and add the module to the @handlers module attribute. + """ + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Dispatch.Handlers + alias Lexical.RemoteControl.Dispatch.PubSub + import Lexical.RemoteControl.Api.Messages + + @handlers [PubSub, Handlers.Indexing] + + # public API + + @doc """ + Registers a process that will receive messages sent directly to its pid. + """ + + def register_listener(listener_pid, message_types) when is_list(message_types) do + :gen_event.call(__MODULE__, PubSub, PubSub.register_message(listener_pid, message_types)) + end + + def register_listener(listener_pid, event_or_all) do + register_listener(listener_pid, List.wrap(event_or_all)) + end + + def add_handler(handler_module, init_args \\ []) do + :gen_event.add_handler(__MODULE__, handler_module, init_args) + end + + def registered?(pid) when is_pid(pid) do + :gen_event.call(__MODULE__, PubSub, PubSub.registered_message(pid)) + end + + def registered?(name) when is_atom(name) do + name in :gen_event.which_handlers(__MODULE__) + end + + def broadcast(message) do + :gen_event.notify(__MODULE__, message) + end + + # GenServer callbacks + + def start_link(opts) do + case :gen_event.start_link(name()) do + {:ok, pid} = success -> + Enum.each(@handlers, &:gen_event.add_handler(pid, &1, [])) + + if opts[:progress] do + register_progress_listener() + end + + success + + error -> + error + end + end + + def child_spec(opts) do + %{ + id: {__MODULE__, :dispatch}, + start: {__MODULE__, :start_link, [opts]} + } + end + + defp name do + {:local, __MODULE__} + end + + defp register_progress_listener do + register_listener(progress_pid(), [project_progress(), percent_progress()]) + end + + defp progress_pid do + project = RemoteControl.get_project() + manager_node_name = RemoteControl.manager_node_name(project) + :rpc.call(manager_node_name, Lexical.Server.Project.Progress, :whereis, [project]) + end +end diff --git a/engine/lib/engine/dispatch/handler.ex b/engine/lib/engine/dispatch/handler.ex new file mode 100644 index 00000000..7675f780 --- /dev/null +++ b/engine/lib/engine/dispatch/handler.ex @@ -0,0 +1,105 @@ +defmodule Lexical.RemoteControl.Dispatch.Handler do + @moduledoc """ + Defines a handler that selectively receives events emitted from a remote control node. + + ## Usage + + Define a handler, specifying the events to be handled and implementing `on_event/2`: + + defmodule MyHandler do + alias Lexical.RemoteControl.Api.Messages + alias Lexical.RemoteControl.Dispatch.Handler + + import Messages + + use Handler, [project_compiled()] + + def on_event(project_compiled(), state) do + ...do something with the message + {:ok, state} + end + end + + Register the handler with dispatch: + + # The second argument here will be passed to the `init/1` callback + Lexical.RemoteControl.Dispatch.add_handler(MyHandler, init_arg) + + """ + @type event :: tuple() + @type handler_state :: term() + + @callback on_event(event(), handler_state) :: {:ok, handler_state} | {:error, any()} + @callback init(term()) :: {:ok, handler_state()} + @optional_callbacks init: 1 + + defmacro __using__(event_types) do + event_types = List.wrap(event_types) + + handler_bodies = + if Enum.member?(event_types, :all) do + [all_handler()] + else + handler_bodies(event_types) + end + + quote do + @behaviour unquote(__MODULE__) + + def init(arg) do + {:ok, arg} + end + + def on(event, state) do + {:ok, event, state} + end + + def handle_call(_, state) do + {:ok, state} + end + + def handle_info(_, state) do + {:ok, state} + end + + unquote_splicing(handler_bodies) + + # handlers only respond to on or info, not calls. + defoverridable init: 1, handle_info: 2, on: 2 + end + end + + def handler_bodies(event_types) do + results = + Enum.map(event_types, fn {event_name, _, _} -> + event_handler(event_name) + end) + + results ++ [ignore_handler()] + end + + defp event_handler(event_name) do + quote do + def handle_event(event, state) + when is_tuple(event) and elem(event, 0) == unquote(event_name) do + on_event(event, state) + end + end + end + + defp all_handler do + quote do + def handle_event(event, state) do + on_event(event, state) + end + end + end + + defp ignore_handler do + quote do + def handle_event(event, state) do + {:ok, state} + end + end + end +end diff --git a/engine/lib/engine/dispatch/handlers/indexing.ex b/engine/lib/engine/dispatch/handlers/indexing.ex new file mode 100644 index 00000000..f20ec4bd --- /dev/null +++ b/engine/lib/engine/dispatch/handlers/indexing.ex @@ -0,0 +1,36 @@ +defmodule Lexical.RemoteControl.Dispatch.Handlers.Indexing do + alias Lexical.Document + alias Lexical.RemoteControl.Api.Messages + alias Lexical.RemoteControl.Commands + alias Lexical.RemoteControl.Dispatch + alias Lexical.RemoteControl.Search + + require Logger + import Messages + + use Dispatch.Handler, [file_compile_requested(), filesystem_event()] + + def on_event(file_compile_requested(uri: uri), state) do + reindex(uri) + {:ok, state} + end + + def on_event(filesystem_event(uri: uri, event_type: :deleted), state) do + delete_path(uri) + {:ok, state} + end + + def on_event(filesystem_event(), state) do + {:ok, state} + end + + defp reindex(uri) do + Commands.Reindex.uri(uri) + end + + def delete_path(uri) do + uri + |> Document.Path.ensure_path() + |> Search.Store.clear() + end +end diff --git a/engine/lib/engine/dispatch/pub_sub.ex b/engine/lib/engine/dispatch/pub_sub.ex new file mode 100644 index 00000000..887cc46f --- /dev/null +++ b/engine/lib/engine/dispatch/pub_sub.ex @@ -0,0 +1,120 @@ +defmodule Lexical.RemoteControl.Dispatch.PubSub do + @moduledoc """ + A pubsub event handler for a gen_event controller. + """ + defmodule State do + alias Lexical.Project + + defstruct [:registrations] + + def new do + %__MODULE__{registrations: %{}} + end + + def add(%__MODULE__{} = state, message_type, pid) do + registrations = + Map.update(state.registrations, message_type, [pid], fn registrations -> + [pid | registrations] + end) + + %__MODULE__{state | registrations: registrations} + end + + def registrations(%__MODULE__{} = state, message_type) do + all = Map.get(state.registrations, :all, []) + specific = Map.get(state.registrations, message_type, []) + all ++ specific + end + + def registered?(%__MODULE__{} = state, pid) do + state.registrations + |> Map.values() + |> List.flatten() + |> Enum.member?(pid) + end + + def registered?(%__MODULE__{} = state, message_type, pid) do + pid in registrations(state, message_type) + end + + def remove(%__MODULE__{} = state, message_type, pid) do + registrations = + Map.update(state.registrations, message_type, [], &Enum.reject(&1, fn e -> e == pid end)) + + %__MODULE__{state | registrations: registrations} + end + + def remove_all(%__MODULE__{} = state, pid) do + registrations = + Map.new(state.registrations, fn {message, pids} -> + pids = Enum.reject(pids, &(&1 == pid)) + {message, pids} + end) + + %__MODULE__{state | registrations: registrations} + end + end + + alias Lexical.Project + + @behaviour :gen_event + + def register_message(listener_pid, message_types) do + {:register, listener_pid, message_types} + end + + def registered_message(pid) do + {:registered?, pid} + end + + @impl :gen_event + def init(_) do + {:ok, State.new()} + end + + @impl :gen_event + def handle_call({:register, listener_pid, message_types}, %State{} = state) do + Process.monitor(listener_pid) + + new_state = + Enum.reduce(message_types, state, fn + message_type_or_message, %State{} = state -> + message_type = extract_message_type(message_type_or_message) + State.add(state, message_type, listener_pid) + end) + + {:ok, :ok, new_state} + end + + @impl :gen_event + def handle_call({:registered?, pid}, %State{} = state) do + registered? = State.registered?(state, pid) + {:ok, registered?, state} + end + + @impl :gen_event + def handle_info({:DOWN, _ref, _, pid, _}, %State{} = state) do + new_state = State.remove_all(state, pid) + {:ok, new_state} + end + + @impl :gen_event + def handle_event(message, %State{} = state) do + message_type = extract_message_type(message) + + state + |> State.registrations(message_type) + |> Enum.each(&send(&1, message)) + + {:ok, state} + end + + def name(%Project{} = project) do + :"#{Project.name(project)}::dispatch" + end + + # Private api + + defp extract_message_type(message_type) when is_atom(message_type), do: message_type + defp extract_message_type(message_type) when is_tuple(message_type), do: elem(message_type, 0) +end diff --git a/engine/lib/engine/document_symbols.ex b/engine/lib/engine/document_symbols.ex deleted file mode 100644 index 47305fad..00000000 --- a/engine/lib/engine/document_symbols.ex +++ /dev/null @@ -1,237 +0,0 @@ -defmodule Engine.DocumentSymbol do - @moduledoc false - - alias GenLSP.Enumerations.SymbolKind - alias GenLSP.Structures.DocumentSymbol - alias GenLSP.Structures.Position - alias GenLSP.Structures.Range - - @spec fetch(text :: String.t()) :: list(DocumentSymbol.t()) - def fetch(text) do - ast = - case Spitfire.parse( - text, - # we set the literal encoder so that we can know when atoms and strings start and end - # this makes it useful for knowing the exact locations of struct field definitions - literal_encoder: fn literal, meta -> - if is_atom(literal) or is_binary(literal) do - {:ok, {:__literal__, meta, [literal]}} - else - {:ok, literal} - end - end, - unescape: false, - token_metadata: true, - columns: true - ) do - {:error, ast, _errors} -> - ast - - {:error, _} -> - raise "Failed to parse!" - - {:ok, ast} -> - ast - end - - List.wrap(walker(ast, nil)) - end - - defp walker([{{:__literal__, _, [:do]}, {_, _, _exprs} = ast}], mod) do - walker(ast, mod) - end - - defp walker({:__block__, _, exprs}, mod) do - for expr <- exprs, sym = walker(expr, mod), sym != nil do - sym - end - end - - defp walker({:defmodule, meta, [name | children]}, _mod) do - name = Macro.to_string(unliteral(name)) - - %DocumentSymbol{ - name: name, - kind: SymbolKind.module(), - children: - List.flatten(for(child <- children, sym = walker(child, name), sym != nil, do: sym)), - range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:end][:line] - 1, character: meta[:end][:column] - 1} - }, - selection_range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:line] - 1, character: meta[:column] - 1} - } - } - end - - defp walker({:describe, meta, [name | children]}, mod) do - name = String.replace("describe " <> Macro.to_string(unliteral(name)), "\n", "") - - %DocumentSymbol{ - name: name, - kind: SymbolKind.class(), - children: - List.flatten(for(child <- children, sym = walker(child, mod), sym != nil, do: sym)), - range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:end][:line] - 1, character: meta[:end][:column] - 1} - }, - selection_range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:line] - 1, character: meta[:column] - 1} - } - } - end - - defp walker({:defstruct, meta, [fields]}, mod) do - fields = - for field <- fields do - {name, start_line, start_column} = - case field do - {:__literal__, meta, [name]} -> - start_line = meta[:line] - 1 - start_column = meta[:column] - 1 - name = Macro.to_string(name) - - {name, start_line, start_column} - - {{:__literal__, meta, [name]}, default} -> - start_line = meta[:line] - 1 - start_column = meta[:column] - 1 - name = to_string(name) <> ": " <> Macro.to_string(unliteral(default)) - - {name, start_line, start_column} - end - - %DocumentSymbol{ - name: name, - children: [], - kind: SymbolKind.field(), - range: %Range{ - start: %Position{ - line: start_line, - character: start_column - }, - end: %Position{ - line: start_line, - character: start_column + String.length(name) - } - }, - selection_range: %Range{ - start: %Position{line: start_line, character: start_column}, - end: %Position{line: start_line, character: start_column} - } - } - end - - %DocumentSymbol{ - name: "%#{mod}{}", - children: fields, - kind: elixir_kind_to_lsp_kind(:defstruct), - range: %Range{ - start: %Position{ - line: meta[:line] - 1, - character: meta[:column] - 1 - }, - end: %Position{ - line: (meta[:end_of_expression][:line] || meta[:line]) - 1, - character: (meta[:end_of_expression][:column] || meta[:column]) - 1 - } - }, - selection_range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:line] - 1, character: meta[:column] - 1} - } - } - end - - defp walker({:@, meta, [{_name, _, value}]} = attribute, _) when length(value) > 0 do - %DocumentSymbol{ - name: attribute |> unliteral() |> Macro.to_string() |> String.replace("\n", ""), - children: [], - kind: elixir_kind_to_lsp_kind(:@), - range: %Range{ - start: %Position{ - line: meta[:line] - 1, - character: meta[:column] - 1 - }, - end: %Position{ - line: (meta[:end_of_expression] || meta)[:line] - 1, - character: (meta[:end_of_expression] || meta)[:column] - 1 - } - }, - selection_range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:line] - 1, character: meta[:column] - 1} - } - } - end - - defp walker({type, meta, [name | _children]}, _) when type in [:test, :feature, :property] do - %DocumentSymbol{ - name: String.replace("#{type} #{Macro.to_string(unliteral(name))}", "\n", ""), - children: [], - kind: SymbolKind.constructor(), - range: %Range{ - start: %Position{ - line: meta[:line] - 1, - character: meta[:column] - 1 - }, - end: %Position{ - line: (meta[:end] || meta[:end_of_expression] || meta)[:line] - 1, - character: (meta[:end] || meta[:end_of_expression] || meta)[:column] - 1 - } - }, - selection_range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:line] - 1, character: meta[:column] - 1} - } - } - end - - defp walker({type, meta, [name | _children]}, _) - when type in [:def, :defp, :defmacro, :defmacro] do - %DocumentSymbol{ - name: String.replace("#{type} #{name |> unliteral() |> Macro.to_string()}", "\n", ""), - children: [], - kind: elixir_kind_to_lsp_kind(type), - range: %Range{ - start: %Position{ - line: meta[:line] - 1, - character: meta[:column] - 1 - }, - end: %Position{ - line: (meta[:end] || meta[:end_of_expression] || meta)[:line] - 1, - character: (meta[:end] || meta[:end_of_expression] || meta)[:column] - 1 - } - }, - selection_range: %Range{ - start: %Position{line: meta[:line] - 1, character: meta[:column] - 1}, - end: %Position{line: meta[:line] - 1, character: meta[:column] - 1} - } - } - end - - defp walker(_ast, _) do - nil - end - - defp unliteral(ast) do - Macro.prewalk(ast, fn - {:__literal__, _, [literal]} -> - literal - - node -> - node - end) - end - - defp elixir_kind_to_lsp_kind(:defstruct), do: SymbolKind.struct() - defp elixir_kind_to_lsp_kind(:@), do: SymbolKind.property() - - defp elixir_kind_to_lsp_kind(kind) - when kind in [:def, :defp, :defmacro, :defmacrop, :test, :describe], - do: SymbolKind.function() -end diff --git a/engine/lib/engine/mix.ex b/engine/lib/engine/mix.ex new file mode 100644 index 00000000..e64f5230 --- /dev/null +++ b/engine/lib/engine/mix.ex @@ -0,0 +1,54 @@ +defmodule Lexical.RemoteControl.Mix do + alias Lexical.Project + alias Lexical.RemoteControl + + def in_project(fun) do + if RemoteControl.project_node?() do + in_project(RemoteControl.get_project(), fun) + else + {:error, :not_project_node} + end + end + + def in_project(%Project{} = project, fun) do + # Locking on the build make sure we don't get a conflict on the mix.exs being + # already defined + + old_cwd = File.cwd!() + + with_lock(fn -> + try do + Mix.ProjectStack.post_config(prune_code_paths: false) + + build_path = RemoteControl.Build.path(project) + project_root = Project.root_path(project) + + project + |> Project.atom_name() + |> Mix.Project.in_project(project_root, [build_path: build_path], fun) + rescue + ex -> + blamed = Exception.blame(:error, ex, __STACKTRACE__) + {:error, {:exception, blamed, __STACKTRACE__}} + else + result -> + case result do + error when is_tuple(error) and elem(error, 0) == :error -> + error + + ok when is_tuple(ok) and elem(ok, 0) == :ok -> + ok + + other -> + {:ok, other} + end + after + File.cd!(old_cwd) + end + end) + end + + defp with_lock(fun) do + RemoteControl.with_lock(__MODULE__, fun) + end +end diff --git a/engine/lib/engine/mix.tasks.deps.safe_compile.ex b/engine/lib/engine/mix.tasks.deps.safe_compile.ex new file mode 100644 index 00000000..51d871cc --- /dev/null +++ b/engine/lib/engine/mix.tasks.deps.safe_compile.ex @@ -0,0 +1,381 @@ +defmodule Mix.Tasks.Deps.SafeCompile do + use Mix.Task + + @shortdoc "Compiles dependencies" + + @moduledoc """ + Compiles dependencies. + + By default, this task attempts to compile all dependencies. + A list of dependencies can be given to compile multiple + dependencies in order. + + This task attempts to detect if the project contains one of + the following files and act accordingly: + + * `mix.exs` - invokes `mix compile` + * `rebar.config` - invokes `rebar compile` + * `Makefile.win`- invokes `nmake /F Makefile.win` (only on Windows) + * `Makefile` - invokes `gmake` on DragonFlyBSD, FreeBSD, NetBSD, and OpenBSD, + invokes `make` on any other operating system (except on Windows) + + The compilation can be customized by passing a `compile` option + in the dependency: + + {:some_dependency, "0.1.0", compile: "command to compile"} + + If a list of dependencies is given, Mix will attempt to compile + them as is. For example, if project `a` depends on `b`, calling + `mix deps.compile a` will compile `a` even if `b` is out of + date. This is to allow parts of the dependency tree to be + recompiled without propagating those changes upstream. To ensure + `b` is included in the compilation step, pass `--include-children`. + + ## Command line options + + * `--force` - force compilation of deps + * `--skip-umbrella-children` - skips umbrella applications from compiling + * `--skip-local-deps` - skips non-remote dependencies, such as path deps, from compiling + + """ + + @switches [ + include_children: :boolean, + force: :boolean, + skip_umbrella_children: :boolean, + skip_local_deps: :boolean + ] + + @impl true + def run(args) do + if Elixir.Features.compile_keeps_current_directory?() do + Mix.Tasks.Deps.Compile.run(args) + else + unless "--no-archives-check" in args do + Mix.Task.run("archive.check", args) + end + + Mix.Project.get!() + deps = Mix.Dep.load_and_cache() + + case OptionParser.parse(args, switches: @switches) do + {opts, [], _} -> + # Because this command may be invoked explicitly with + # deps.compile, we simply try to compile any available + # or local dependency. + compile(filter_available_and_local_deps(deps), opts) + + {opts, tail, _} -> + compile(Mix.Dep.filter_by_name(tail, deps, opts), opts) + end + end + end + + @doc false + def compile(deps, options \\ []) do + shell = Mix.shell() + config = Mix.Project.deps_config() + Mix.Task.run("deps.precompile") + + compiled = + deps + |> reject_umbrella_children(options) + |> reject_local_deps(options) + |> Enum.map(fn %Mix.Dep{app: app, status: status, opts: opts, scm: scm} = dep -> + check_unavailable!(app, scm, status) + maybe_clean(dep, options) + + compiled? = + cond do + not is_nil(opts[:compile]) -> + do_compile(dep, config) + + Mix.Dep.mix?(dep) -> + do_mix(dep, config) + + Mix.Dep.make?(dep) -> + do_make(dep, config) + + dep.manager == :rebar3 -> + do_rebar3(dep, config) + + true -> + shell.error( + ~s[Could not compile #{inspect(app)}, no "mix.exs", "rebar.config" or "Makefile"] <> + ~s[pass :compile as an option to customize compilation, set it to "false" to do nothing] + ) + + false + end + + # We should touch fetchable dependencies even if they + # did not compile otherwise they will always be marked + # as stale, even when there is nothing to do. + fetchable? = touch_fetchable(scm, opts[:build]) + + compiled? and fetchable? + end) + + if true in compiled, do: Mix.Task.run("will_recompile"), else: :ok + end + + defp maybe_clean(dep, opts) do + # If a dependency was marked as fetched or with an out of date lock + # or missing the app file, we always compile it from scratch. + if Keyword.get(opts, :force, false) or Mix.Dep.compilable?(dep) do + File.rm_rf!(Path.join([Mix.Project.build_path(), "lib", Atom.to_string(dep.app)])) + end + end + + defp touch_fetchable(scm, path) do + if scm.fetchable? do + path = Path.join(path, ".mix") + File.mkdir_p!(path) + File.touch!(Path.join(path, "compile.fetch")) + true + else + false + end + end + + defp check_unavailable!(app, scm, {:unavailable, path}) do + if scm.fetchable? do + Mix.raise( + "Cannot compile dependency #{inspect(app)} because " <> + "it isn't available, run \"mix deps.get\" first" + ) + else + Mix.raise( + "Cannot compile dependency #{inspect(app)} because " <> + "it isn't available, please ensure the dependency is at " <> + inspect(Path.relative_to_cwd(path)) + ) + end + end + + defp check_unavailable!(_, _, _) do + :ok + end + + defp do_mix(dep, _config) do + Mix.Dep.in_dependency(dep, fn _ -> + config = Mix.Project.config() + + if req = old_elixir_req(config) do + Mix.shell().error( + "warning: the dependency #{inspect(dep.app)} requires Elixir #{inspect(req)} " <> + "but you are running on v#{System.version()}" + ) + end + + try do + options = [ + "--from-mix-deps-compile", + "--no-archives-check", + "--no-warnings-as-errors" + ] + + res = Mix.Task.run("compile", options) + match?({:ok, _}, res) + catch + kind, reason -> + app = dep.app + + Mix.shell().error( + "could not compile dependency #{inspect(app)}, \"mix compile\" failed. " <> + deps_compile_feedback(app) + ) + + :erlang.raise(kind, reason, __STACKTRACE__) + end + end) + end + + defp do_rebar3(%Mix.Dep{opts: opts} = dep, config) do + dep_path = opts[:dest] + build_path = opts[:build] + + # For Rebar3, we need to copy the source/ebin to the target/ebin + # before we run the command given that REBAR_BARE_COMPILER_OUTPUT_DIR + # writes directly to _build. + # + # credo:disable-for-next-line Credo.Check.Design.TagTODO + # TODO: We still symlink ebin/ by default for backwards compatibility. + # This partially negates the effects of REBAR_BARE_COMPILER_OUTPUT_DIR + # if an ebin directory exists, so we should consider disabling it in future + # releases when rebar3 v3.14+ is reasonably adopted. + config = Keyword.put(config, :app_path, build_path) + Mix.Project.build_structure(config, symlink_ebin: true, source: dep_path) + + # Build the rebar config and setup the command line + config_path = Path.join(build_path, "mix.rebar.config") + lib_path = Path.join(config[:env_path], "lib/*/ebin") + File.write!(config_path, rebar_config(dep)) + + env = [ + # REBAR_BARE_COMPILER_OUTPUT_DIR is only honored by rebar3 >= 3.14 + {"REBAR_BARE_COMPILER_OUTPUT_DIR", build_path}, + {"REBAR_CONFIG", config_path}, + {"REBAR_PROFILE", "prod"}, + {"TERM", "dumb"} + ] + + cmd = "#{rebar_cmd(dep)} bare compile --paths #{lib_path}" + do_command(dep, config, cmd, false, env) + + build_priv = Path.join(build_path, "priv") + dep_priv = Path.join(dep_path, "priv") + + # Copy priv/ after compilation too if it was created then + if File.exists?(dep_priv) and not File.exists?(build_priv) do + Mix.Utils.symlink_or_copy(dep_priv, build_priv) + end + + Code.prepend_path(Path.join(build_path, "ebin")) + true + end + + defp rebar_config(dep) do + dep.extra + |> Mix.Rebar.dependency_config() + |> Mix.Rebar.serialize_config() + end + + defp rebar_cmd(%Mix.Dep{manager: manager} = dep) do + Mix.Rebar.rebar_cmd(manager) || handle_rebar_not_found(dep) + end + + defp handle_rebar_not_found(%Mix.Dep{app: app, manager: manager}) do + shell = Mix.shell() + + shell.info( + "Could not find \"#{manager}\", which is needed to build dependency #{inspect(app)}" + ) + + shell.info("I can install a local copy which is just used by Mix") + + install_question = + "Shall I install #{manager}? (if running non-interactively, " <> + "use \"mix local.rebar --force\")" + + unless shell.yes?(install_question) do + error_message = + "Could not find \"#{manager}\" to compile " <> + "dependency #{inspect(app)}, please ensure \"#{manager}\" is available" + + Mix.raise(error_message) + end + + (Mix.Tasks.Local.Rebar.run([]) && Mix.Rebar.local_rebar_cmd(manager)) || + Mix.raise("\"#{manager}\" installation failed") + end + + defp do_make(dep, config) do + command = make_command(dep) + do_command(dep, config, command, true, [{"IS_DEP", "1"}]) + build_structure(dep, config) + true + end + + defp make_command(dep) do + makefile_win? = makefile_win?(dep) + + command = + case :os.type() do + {:win32, _} when makefile_win? -> + "nmake /F Makefile.win" + + {:unix, type} when type in [:dragonfly, :freebsd, :netbsd, :openbsd] -> + "gmake" + + _ -> + "make" + end + + if erlang_mk?(dep) do + "#{command} clean && #{command}" + else + command + end + end + + defp do_compile(%Mix.Dep{opts: opts} = dep, config) do + if command = opts[:compile] do + do_command(dep, config, command, true) + build_structure(dep, config) + true + else + false + end + end + + defp do_command(dep, config, command, print_app?, env \\ []) do + %Mix.Dep{app: app, system_env: system_env, opts: opts} = dep + + env = [{"ERL_LIBS", Path.join(config[:env_path], "lib")} | system_env] ++ env + + if Mix.shell().cmd(command, env: env, print_app: print_app?, cd: opts[:dest]) != 0 do + Mix.raise( + "Could not compile dependency #{inspect(app)}, \"#{command}\" command failed. " <> + deps_compile_feedback(app) + ) + end + + true + end + + defp build_structure(%Mix.Dep{opts: opts}, config) do + config = Keyword.put(config, :app_path, opts[:build]) + Mix.Project.build_structure(config, symlink_ebin: true, source: opts[:dest]) + Code.prepend_path(Path.join(opts[:build], "ebin")) + end + + defp old_elixir_req(config) do + req = config[:elixir] + + if req && not Version.match?(System.version(), req) do + req + end + end + + defp erlang_mk?(%Mix.Dep{opts: opts}) do + File.regular?(Path.join(opts[:dest], "erlang.mk")) + end + + defp makefile_win?(%Mix.Dep{opts: opts}) do + File.regular?(Path.join(opts[:dest], "Makefile.win")) + end + + defp reject_umbrella_children(deps, options) do + if options[:skip_umbrella_children] do + Enum.reject(deps, fn %{opts: opts} -> Keyword.get(opts, :from_umbrella) == true end) + else + deps + end + end + + defp filter_available_and_local_deps(deps) do + Enum.filter(deps, fn dep -> + Mix.Dep.available?(dep) or not dep.scm.fetchable? + end) + end + + defp reject_local_deps(deps, options) do + if options[:skip_local_deps] do + Enum.filter(deps, fn %{scm: scm} -> scm.fetchable? end) + else + deps + end + end + + defp deps_compile_feedback(app) do + if Mix.install?() do + "Errors may have been logged above. You may run Mix.install/2 to try again or " <> + "change the arguments to Mix.install/2 to try another version" + else + "Errors may have been logged above. You can recompile this dependency with " <> + ~s["mix deps.compile #{app}", update it with "mix deps.update #{app}" or ] <> + ~s[clean it with "mix deps.clean #{app}"] + end + end +end diff --git a/engine/lib/engine/module/loader.ex b/engine/lib/engine/module/loader.ex new file mode 100644 index 00000000..149c3d06 --- /dev/null +++ b/engine/lib/engine/module/loader.ex @@ -0,0 +1,43 @@ +defmodule Lexical.RemoteControl.Module.Loader do + @moduledoc """ + Apparently, Code.ensure_loaded?/1 is pretty slow. I'm guessing because it has to do a + round trip to the code server for each check. This in turn slows down indexing, so the thought + is that having a cache will improve performance + """ + + alias Future.Code + use Agent + + def start_link(_) do + initialize = fn -> + Map.new(:code.all_loaded(), fn {name, _} -> {:module, name} end) + end + + Agent.start_link(initialize, name: __MODULE__) + end + + def ensure_loaded(module_name) do + Agent.get_and_update(__MODULE__, fn + %{^module_name => result} = state -> + {result, state} + + state -> + result = Code.ensure_loaded(module_name) + {result, Map.put(state, module_name, result)} + end) + end + + def ensure_loaded?(module_name) do + match?({:module, ^module_name}, ensure_loaded(module_name)) + end + + def loaded?(module_name) do + Agent.get(__MODULE__, fn + %{^module_name => {:module, _}} -> + true + + _ -> + false + end) + end +end diff --git a/engine/lib/engine/module_mappings.ex b/engine/lib/engine/module_mappings.ex new file mode 100644 index 00000000..bcb8ce71 --- /dev/null +++ b/engine/lib/engine/module_mappings.ex @@ -0,0 +1,85 @@ +defmodule Lexical.RemoteControl.ModuleMappings do + defmodule State do + defstruct module_to_file: %{}, file_to_modules: %{} + + def new do + %__MODULE__{} + end + + def file_for_module(%__MODULE__{} = state, module) do + Map.get(state.module_to_file, module) + end + + def modules_in_file(%__MODULE__{} = state, file_path) do + Map.get(state.file_to_modules, file_path, []) + end + + def update(%__MODULE__{} = state, module, file_path) do + file_to_modules = + case state.module_to_file do + %{^module => ^file_path} -> + # the module has already been associated with this path + state.file_to_modules + + %{^module => old_path} -> + # the module has changed its file + remove_this_module? = fn old_module -> old_module == module end + + state.file_to_modules + |> Map.update(old_path, [], &Enum.reject(&1, remove_this_module?)) + |> Map.update(file_path, [module], &[module | &1]) + + _ -> + # it didn't exist previously + Map.update(state.file_to_modules, file_path, [module], &[module | &1]) + end + + module_to_file = Map.put(state.module_to_file, module, file_path) + %__MODULE__{state | file_to_modules: file_to_modules, module_to_file: module_to_file} + end + end + + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Api.Messages + + use GenServer + + import Messages + + # Public + def start_link(_) do + GenServer.start_link(__MODULE__, :ok, name: __MODULE__) + end + + def file_for_module(module) do + GenServer.call(__MODULE__, {:file_for_module, module}) + end + + def modules_in_file(file_path) do + GenServer.call(__MODULE__, {:modules_in_file, file_path}) + end + + # GenServer callbacks + + @impl GenServer + def init(_) do + RemoteControl.register_listener(self(), [module_updated()]) + {:ok, State.new()} + end + + @impl GenServer + def handle_call({:modules_in_file, file_path}, _from, %State{} = state) do + {:reply, State.modules_in_file(state, file_path), state} + end + + @impl GenServer + def handle_call({:file_for_module, module}, _from, %State{} = state) do + {:reply, State.file_for_module(state, module), state} + end + + @impl GenServer + def handle_info(module_updated(name: module_name, file: file_path), %State{} = state) do + new_state = State.update(state, module_name, file_path) + {:noreply, new_state} + end +end diff --git a/engine/lib/engine/modules.ex b/engine/lib/engine/modules.ex new file mode 100644 index 00000000..3b32e871 --- /dev/null +++ b/engine/lib/engine/modules.ex @@ -0,0 +1,255 @@ +defmodule Lexical.RemoteControl.Modules do + @moduledoc """ + Utilities for dealing with modules on the remote control node + """ + + alias Future.Code.Typespec + alias Lexical.RemoteControl.Module.Loader + + @typedoc "Module documentation record as defined by EEP-48" + @type docs_v1 :: tuple() + + @typedoc "A type, spec, or callback definition" + @type definition :: + {name :: atom(), arity :: arity(), formatted :: String.t(), quoted :: Macro.t()} + + @cache_timeout Application.compile_env(:remote_control, :modules_cache_expiry, {10, :second}) + + @doc """ + Ensure the given module is compiled, returning the BEAM object code if successful. + """ + @spec ensure_beam(module()) :: + {:ok, beam :: binary()} | {:error, reason} + when reason: + :embedded + | :badfile + | :nofile + | :on_load_failure + | :unavailable + | :get_object_code_failed + def ensure_beam(module) when is_atom(module) do + with {:module, _} <- Code.ensure_compiled(module), + {_module, beam, _filename} <- :code.get_object_code(module) do + {:ok, beam} + else + :error -> {:error, :get_object_code_failed} + {:error, error} -> {:error, error} + end + end + + @doc """ + Fetch the docs chunk from BEAM object code. + """ + @spec fetch_docs(beam :: binary()) :: {:ok, docs_v1()} | :error + @docs_chunk ~c"Docs" + def fetch_docs(beam) when is_binary(beam) do + case :beam_lib.chunks(beam, [@docs_chunk]) do + {:ok, {_module, [{@docs_chunk, bin}]}} -> + {:ok, :erlang.binary_to_term(bin)} + + _ -> + :error + end + end + + @doc """ + Fetch the specs from BEAM object code. + """ + @spec fetch_specs(beam :: binary()) :: {:ok, [definition()]} | :error + def fetch_specs(beam) when is_binary(beam) do + case Typespec.fetch_specs(beam) do + {:ok, specs} -> + defs = + for {{name, arity}, defs} <- specs, + def <- defs do + quoted = Typespec.spec_to_quoted(name, def) + formatted = format_definition(quoted) + + {name, arity, formatted, quoted} + end + + {:ok, defs} + + _ -> + :error + end + end + + @doc """ + Fetch the types from BEAM object code. + """ + @spec fetch_types(beam :: binary()) :: {:ok, [definition()]} | :error + def fetch_types(beam) when is_binary(beam) do + case Typespec.fetch_types(beam) do + {:ok, types} -> + defs = + for {kind, {name, _body, args} = type} <- types do + arity = length(args) + quoted_type = Typespec.type_to_quoted(type) + quoted = {:@, [], [{kind, [], [quoted_type]}]} + formatted = format_definition(quoted) + + {name, arity, formatted, quoted} + end + + {:ok, defs} + + _ -> + :error + end + end + + @doc """ + Fetch the specs from BEAM object code. + """ + @spec fetch_callbacks(beam :: binary()) :: {:ok, [definition()]} | :error + def fetch_callbacks(beam) when is_binary(beam) do + case Typespec.fetch_callbacks(beam) do + {:ok, callbacks} -> + defs = + for {{name, arity}, defs} <- callbacks, + def <- defs do + quoted = Typespec.spec_to_quoted(name, def) + formatted = format_definition(quoted) + + {name, arity, formatted, quoted} + end + + {:ok, defs} + + _ -> + :error + end + end + + @doc """ + Get a list of a module's functions + + This function will attempt to load the given module using our module cache, and + if it's found, will return a keyword list of function names and arities. + """ + @spec fetch_functions(module()) :: {:ok, [{function(), arity()}]} | :error + def fetch_functions(module) when is_atom(module) do + with {:module, module} <- Loader.ensure_loaded(module) do + cond do + function_exported?(module, :__info__, 1) -> + {:ok, module.__info__(:functions)} + + function_exported?(module, :module_info, 1) -> + {:ok, module.module_info(:functions)} + + true -> + :error + end + end + end + + defp format_definition(quoted) do + quoted + |> Future.Code.quoted_to_algebra() + |> Inspect.Algebra.format(60) + |> IO.iodata_to_binary() + end + + @doc """ + Returns all modules matching a prefix + + `with_prefix` returns all modules on the node on which it runs that start with the given prefix. + It's worth noting that it will return _all modules_ regardless if they have been loaded or not. + + You can optionally pass a predicate MFA to further select which modules are returned, but + it's important to understand that the predicate can only be a function reference to a function that + exists on the `remote_control` node. I.e. you CANNOT pass anonymous functions to this module. + + Each module will be added as the first argument to the given list of args in the predicate, + for example: + + iex> Modules.with_prefix("Gen", {Kernel, :macro_exported?, [:__using__, 1]}) + [GenEvent, GenServer] + + """ + def with_prefix(prefix_module, predicate_mfa \\ {Function, :identity, []}) + + def with_prefix(prefix_module, mfa) when is_atom(prefix_module) do + prefix_module + |> to_string() + |> with_prefix(mfa) + end + + def with_prefix("Elixir." <> _ = prefix, mfa) do + results = + for {module_string, already_loaded?} <- all_modules(), + String.starts_with?(module_string, prefix), + module = Module.concat([module_string]), + ensure_loaded?(module, already_loaded?), + apply_predicate(module, mfa) do + {module_string, module} + end + + {module_strings, modules_with_prefix} = Enum.unzip(results) + + mark_loaded(module_strings) + + modules_with_prefix + end + + def with_prefix(prefix, mfa) do + with_prefix("Elixir." <> prefix, mfa) + end + + defp apply_predicate(module_arg, {invoked_module, function, args}) do + apply(invoked_module, function, [module_arg | args]) + end + + defp ensure_loaded?(_, true), do: true + defp ensure_loaded?(module, _), do: Loader.ensure_loaded?(module) + + defp mark_loaded(modules) when is_list(modules) do + newly_loaded = Map.new(modules, &{&1, true}) + {expires, all_loaded} = :persistent_term.get(__MODULE__) + updated = Map.merge(all_loaded, newly_loaded) + + :persistent_term.put(__MODULE__, {expires, updated}) + end + + defp all_modules do + case term() do + {:ok, modules} -> + modules + + :error -> + {_expires, modules} = cache = rebuild_cache() + :persistent_term.put(__MODULE__, cache) + modules + end + end + + defp term do + {expires_at, modules} = :persistent_term.get(__MODULE__, {nil, []}) + + if expired?(expires_at) do + :error + else + {:ok, modules} + end + end + + defp expired?(nil), do: true + + defp expired?(expires) do + DateTime.compare(DateTime.utc_now(), expires) == :gt + end + + defp rebuild_cache do + {amount, unit} = @cache_timeout + + expires = DateTime.add(DateTime.utc_now(), amount, unit) + + module_map = + Map.new(:code.all_available(), fn {module_charlist, _path, already_loaded?} -> + {to_string(module_charlist), already_loaded?} + end) + + {expires, module_map} + end +end diff --git a/engine/lib/engine/plugin.ex b/engine/lib/engine/plugin.ex new file mode 100644 index 00000000..f99fdba5 --- /dev/null +++ b/engine/lib/engine/plugin.ex @@ -0,0 +1,48 @@ +defmodule Lexical.RemoteControl.Plugin do + alias Lexical.Document + alias Lexical.Project + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Api.Messages + alias Lexical.RemoteControl.Plugin.Runner + + import Messages + + def diagnose(%Project{} = project, build_number) do + on_complete = fn + [] -> + :ok + + [_ | _] = diagnostics -> + message = + project_diagnostics( + project: project, + build_number: build_number, + diagnostics: diagnostics + ) + + RemoteControl.broadcast(message) + end + + Runner.diagnose(project, on_complete) + end + + def diagnose(%Project{} = project, build_number, %Document{} = document) do + on_complete = fn + [] -> + :ok + + [_ | _] = diagnostics -> + message = + file_diagnostics( + project: project, + build_number: build_number, + uri: document.uri, + diagnostics: diagnostics + ) + + RemoteControl.broadcast(message) + end + + Runner.diagnose(document, on_complete) + end +end diff --git a/engine/lib/engine/plugin/discovery.ex b/engine/lib/engine/plugin/discovery.ex new file mode 100644 index 00000000..4633218c --- /dev/null +++ b/engine/lib/engine/plugin/discovery.ex @@ -0,0 +1,73 @@ +defmodule Lexical.RemoteControl.Plugin.Discovery do + @moduledoc """ + Discovers any plugins in any loaded applications + + This module runs through the loaded applications and checks to see if any of them are lexical plugins. + If a plugin is found, the app is then registered with the plugin system. + + If we're running in a namespaced build, we must apply the same namespace to the plugin's modules, or it + will be looking for structs like `Lexical.Document`, and be passed in structs like `LXRelease.Document`, + and the plugin will crash. + """ + + alias Lexical.RemoteControl.Module.Loader + alias Lexical.RemoteControl.Plugin.Runner + alias Mix.Tasks.Namespace + + require Logger + + @namespaced_document_module [:Lexical, :Document] + |> Module.concat() + |> Namespace.Module.apply() + + def run do + for {app_name, _, _} <- :application.loaded_applications(), + Runner.plugin_app?(app_name) do + load_plugin_app(app_name) + end + + Logger.info("Loaded #{inspect(Runner.enabled_plugins())}") + end + + defp load_plugin_app(app_name) do + with {:ok, modules} <- :application.get_key(app_name, :modules) do + modules + |> maybe_namespace() + |> Runner.register_all() + end + end + + defp maybe_namespace(modules) when is_list(modules) do + if namespaced?() do + Enum.each(modules, fn module -> + namespace_module(module) + unload_module(module) + Loader.ensure_loaded?(module) + end) + end + + modules + end + + defp namespace_module(module) when is_atom(module) do + module + |> :code.which() + |> List.to_string() + |> Namespace.Transform.Beams.apply() + end + + defp unload_module(module) do + unless :code.delete(module) do + :code.purge(module) + :code.delete(module) + end + end + + def namespaced_doc do + @namespaced_document_module + end + + defp namespaced? do + Loader.ensure_loaded?(@namespaced_document_module) + end +end diff --git a/engine/lib/engine/plugin/runner.ex b/engine/lib/engine/plugin/runner.ex new file mode 100644 index 00000000..23af365d --- /dev/null +++ b/engine/lib/engine/plugin/runner.ex @@ -0,0 +1,118 @@ +defmodule Lexical.RemoteControl.Plugin.Runner do + @moduledoc false + + alias Lexical.Document + alias Lexical.Project + alias Lexical.RemoteControl.Module.Loader + alias Lexical.RemoteControl.Plugin.Runner + + require Logger + + @project_level_plugin_timeout_ms :timer.seconds(3) + @file_level_plugin_timeout_ms 50 + + @doc false + def clear_config do + :persistent_term.erase(__MODULE__) + end + + @doc false + def plugin_module?(module) when is_atom(module) do + function_exported?(module, :__lexical_plugin__, 0) + end + + @doc false + def plugin_app?(app_name) do + Application.get_env(app_name, lexical_prefixed_atom("plugin"), false) + end + + @doc false + def enabled_plugins do + config() + |> Map.keys() + |> Enum.map(& &1.name()) + end + + @doc false + def diagnose(%Project{} = project, on_complete) do + Runner.Coordinator.run_all( + project, + :diagnostic, + on_complete, + @project_level_plugin_timeout_ms + ) + end + + @doc false + def diagnose(%Document{} = document, on_complete) do + Runner.Coordinator.run_all(document, :diagnostic, on_complete, @file_level_plugin_timeout_ms) + end + + @doc false + def disable(plugin_module) when is_atom(plugin_module) do + Logger.error("Disabling Plugin #{plugin_module.name()} due to errors") + + config() + |> Map.delete(plugin_module) + |> write_config() + end + + @doc false + def register_all(modules) when is_list(modules) do + for module <- modules, + Loader.ensure_loaded?(module), + plugin_module?(module) do + register(module) + end + end + + @doc false + def register(plugin_module) when is_atom(plugin_module) do + current_plugins = config() + + with {:ok, plugin_type} <- fetch_plugin_type(plugin_module), + :error <- Map.fetch(current_plugins, plugin_module), + :ok <- plugin_module.init() do + current_plugins + |> Map.put(plugin_module, plugin_type) + |> write_config() + + :ok + else + error -> + Logger.warning( + "Could not register plugin #{inspect(plugin_module)} because #{inspect(error)}" + ) + + :error + end + end + + @doc false + def plugins_of_type(plugin_type) do + for {plugin_module, ^plugin_type} <- config() do + plugin_module + end + end + + defp config do + :persistent_term.get(__MODULE__, %{}) + end + + defp write_config(config) do + :persistent_term.put(__MODULE__, config) + end + + defp fetch_plugin_type(module) do + if function_exported?(module, :__plugin_type__, 0) do + {:ok, module.__plugin_type__()} + else + :error + end + end + + defp lexical_prefixed_atom(suffix) do + ("lexical_" <> suffix) + |> String.to_atom() + end +end diff --git a/engine/lib/engine/plugin/runner/coordinator.ex b/engine/lib/engine/plugin/runner/coordinator.ex new file mode 100644 index 00000000..0b99ba34 --- /dev/null +++ b/engine/lib/engine/plugin/runner/coordinator.ex @@ -0,0 +1,35 @@ +defmodule Lexical.RemoteControl.Plugin.Runner.Coordinator do + @moduledoc false + + alias Lexical.Formats + alias Lexical.RemoteControl.Plugin.Runner.Coordinator.State + + require Logger + use GenServer + + def run_all(subject, plugin_type, on_complete, timeout) when is_function(on_complete, 1) do + GenServer.call(__MODULE__, {:run_all, subject, plugin_type, on_complete, timeout}) + end + + # GenServer callbacks + + def start_link(_) do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + @impl GenServer + def init(_) do + {:ok, State.new()} + end + + @impl GenServer + def handle_call({:run_all, subject, plugin_type, on_complete, timeout}, _from, %State{} = state) do + {elapsed_us, {results, new_state}} = + :timer.tc(State, :run_all, [state, subject, plugin_type, timeout]) + + Logger.info("Plugins found #{length(results)} results in #{Formats.time(elapsed_us)}") + + on_complete.(results) + {:reply, :ok, new_state} + end +end diff --git a/engine/lib/engine/plugin/runner/coordinator/state.ex b/engine/lib/engine/plugin/runner/coordinator/state.ex new file mode 100644 index 00000000..a30a4617 --- /dev/null +++ b/engine/lib/engine/plugin/runner/coordinator/state.ex @@ -0,0 +1,102 @@ +defmodule Lexical.RemoteControl.Plugin.Runner.Coordinator.State do + @moduledoc false + + alias Lexical.RemoteControl.Plugin.Runner + + defstruct tasks: [], failures: %{} + + @max_plugin_errors 10 + + require Logger + + def new do + %__MODULE__{} + end + + def run_all(%__MODULE__{} = state, subject, plugin_type, timeout) do + tasks_to_plugin_modules = + plugin_type + |> Runner.plugins_of_type() + |> Enum.map(&Runner.Supervisor.async(&1, subject)) + |> Map.new() + + await_results(state, tasks_to_plugin_modules, timeout) + end + + def failure_count(%__MODULE__{} = state, plugin_module) do + Map.get(state.failures, plugin_module, 0) + end + + def remove_task(%__MODULE__{} = state, ref) do + new_tasks = Enum.reject(state.tasks, &(&1.ref == ref)) + %__MODULE__{state | tasks: new_tasks} + end + + defp await_results(%__MODULE__{} = state, tasks_to_plugin_modules, timeout) do + raw_result = + tasks_to_plugin_modules + |> Map.keys() + |> Task.yield_many(timeout) + + {successes, failed} = + raw_result + |> Enum.reduce({[], []}, fn + {_task, {:ok, {:ok, results}}}, {successes, failures} when is_list(results) -> + {[results | successes], failures} + + {task, {:ok, {:ok, _not_list}}}, {successes, failures} -> + reason = "it did not return a list of results" + failure = {:log, task, reason} + {successes, [failure | failures]} + + {task, {:ok, reason}}, {successes, failures} -> + failure = {:log, task, reason} + {successes, [failure | failures]} + + {task, {:exit, reason}}, {successes, failures} -> + failure = {:log, task, reason} + {successes, [failure | failures]} + + {task, nil}, {successes, failures} -> + failure = {:shutdown, task} + {successes, [failure | failures]} + end) + + new_state = + Enum.reduce(failed, state, fn + {:log, %Task{} = task, reason}, state -> + plugin_module = Map.get(tasks_to_plugin_modules, task) + Logger.error("Task #{plugin_module} failed because #{inspect(reason)}") + mark_failed(state, plugin_module) + + {:shutdown, %Task{} = task}, state -> + plugin_module = Map.get(tasks_to_plugin_modules, task) + Logger.error("Task #{plugin_module} did not complete in #{timeout}ms ") + Task.shutdown(task, :brutal_kill) + mark_failed(state, plugin_module) + end) + + results = + successes + |> Enum.reverse() + |> List.flatten() + + {results, new_state} + end + + defp mark_failed(%__MODULE__{} = state, plugin_module) do + new_failures = Map.update(state.failures, plugin_module, 1, &(&1 + 1)) + maybe_shutdown(plugin_module, new_failures) + %__MODULE__{state | failures: new_failures} + end + + defp maybe_shutdown(plugin_module, failure_map) do + case Map.get(failure_map, plugin_module, 0) do + count when count >= @max_plugin_errors -> + Runner.disable(plugin_module) + + _ -> + :ok + end + end +end diff --git a/engine/lib/engine/plugin/supervisor.ex b/engine/lib/engine/plugin/supervisor.ex new file mode 100644 index 00000000..ad950873 --- /dev/null +++ b/engine/lib/engine/plugin/supervisor.ex @@ -0,0 +1,20 @@ +defmodule Lexical.RemoteControl.Plugin.Runner.Supervisor do + @moduledoc false + + def child_spec(_) do + %{ + id: __MODULE__, + start: {Task.Supervisor, :start_link, [[name: name()]]} + } + end + + @spec async(module(), term()) :: {Task.t(), module()} + def async(plugin_module, subject) do + task = Task.Supervisor.async_nolink(name(), plugin_module, :diagnose, [subject]) + {task, plugin_module} + end + + defp name do + Module.concat(__MODULE__, TaskSupervisor) + end +end diff --git a/engine/lib/engine/port.ex b/engine/lib/engine/port.ex new file mode 100644 index 00000000..05a210de --- /dev/null +++ b/engine/lib/engine/port.ex @@ -0,0 +1,87 @@ +defmodule Lexical.RemoteControl.Port do + @moduledoc """ + Utilities for launching ports in the context of a project + """ + + alias Lexical.Project + alias Lexical.RemoteControl + + @type open_opt :: + {:env, list()} + | {:cd, String.t() | charlist()} + | {:env, [{:os.env_var_name(), :os.env_var_value()}]} + | {:args, list()} + + @type open_opts :: [open_opt] + + @doc """ + Launches elixir in a port. + + This function takes the project's context into account and looks for the executable via calling + `RemoteControl.elixir_executable(project)`. Environment variables are also retrieved with that call. + """ + @spec open_elixir(Project.t(), open_opts()) :: port() + def open_elixir(%Project{} = project, opts) do + {:ok, elixir_executable, environment_variables} = RemoteControl.elixir_executable(project) + + opts = + opts + |> Keyword.put_new_lazy(:cd, fn -> Project.root_path(project) end) + |> Keyword.put_new(:env, environment_variables) + + open(project, elixir_executable, opts) + end + + @doc """ + Launches an executable in the project context via a port. + """ + def open(%Project{} = project, executable, opts) do + {launcher, opts} = Keyword.pop_lazy(opts, :path, &path/0) + + opts = + opts + |> Keyword.put_new_lazy(:cd, fn -> Project.root_path(project) end) + |> Keyword.update(:args, [executable], fn old_args -> + [executable | Enum.map(old_args, &to_string/1)] + end) + + opts = + if Keyword.has_key?(opts, :env) do + Keyword.update!(opts, :env, &ensure_charlists/1) + else + opts + end + + Port.open({:spawn_executable, launcher}, opts) + end + + @doc """ + Provides the path of an executable to launch another erlang node via ports. + """ + def path do + path(:os.type()) + end + + def path({:unix, _}) do + with :non_existing <- :code.where_is_file(~c"port_wrapper.sh") do + :remote_control + |> :code.priv_dir() + |> Path.join("port_wrapper.sh") + |> Path.expand() + end + |> to_string() + end + + def path(os_tuple) do + raise ArgumentError, "Operating system #{inspect(os_tuple)} is not currently supported" + end + + defp ensure_charlists(environment_variables) do + Enum.map(environment_variables, fn {key, value} -> + # using to_string ensures nil values won't blow things up + erl_key = key |> to_string() |> String.to_charlist() + erl_value = value |> to_string() |> String.to_charlist() + {erl_key, erl_value} + end) + end +end diff --git a/engine/lib/engine/progress.ex b/engine/lib/engine/progress.ex new file mode 100644 index 00000000..3448609c --- /dev/null +++ b/engine/lib/engine/progress.ex @@ -0,0 +1,68 @@ +defmodule Lexical.RemoteControl.Progress do + alias Lexical.RemoteControl + + import Lexical.RemoteControl.Api.Messages + + @type label :: String.t() + @type message :: String.t() + + @type delta :: pos_integer() + @type on_complete_callback :: (-> any()) + @type report_progress_callback :: (delta(), message() -> any()) + + defmacro __using__(_) do + quote do + import unquote(__MODULE__), only: [with_progress: 2] + end + end + + @spec with_progress(label(), (-> any())) :: any() + def with_progress(label, func) when is_function(func, 0) do + on_complete = begin_progress(label) + + try do + func.() + after + on_complete.() + end + end + + @spec with_percent_progress(label(), pos_integer(), (report_progress_callback() -> any())) :: + any() + def with_percent_progress(label, max, func) when is_function(func, 1) do + {report_progress, on_complete} = begin_percent(label, max) + + try do + func.(report_progress) + after + on_complete.() + end + end + + @spec begin_progress(label :: label()) :: on_complete_callback() + def begin_progress(label) do + RemoteControl.broadcast(project_progress(label: label, stage: :begin)) + + fn -> + RemoteControl.broadcast(project_progress(label: label, stage: :complete)) + end + end + + @spec begin_percent(label(), pos_integer()) :: + {report_progress_callback(), on_complete_callback()} + def begin_percent(label, max) do + RemoteControl.broadcast(percent_progress(label: label, max: max, stage: :begin)) + + report_progress = fn delta, message -> + RemoteControl.broadcast( + percent_progress(label: label, message: message, delta: delta, stage: :report) + ) + end + + complete = fn -> + RemoteControl.broadcast(percent_progress(label: label, stage: :complete)) + end + + {report_progress, complete} + end +end diff --git a/engine/lib/engine/project_node.ex b/engine/lib/engine/project_node.ex new file mode 100644 index 00000000..e79e288f --- /dev/null +++ b/engine/lib/engine/project_node.ex @@ -0,0 +1,244 @@ +defmodule Lexical.RemoteControl.ProjectNode do + alias Lexical.Project + alias Lexical.RemoteControl + require Logger + + defmodule State do + defstruct [ + :project, + :port, + :cookie, + :stopped_by, + :stop_timeout, + :started_by, + :status + ] + + def new(%Project{} = project) do + cookie = Node.get_cookie() + + %__MODULE__{ + project: project, + cookie: cookie, + status: :initializing + } + end + + @dialyzer {:nowarn_function, start: 3} + + def start(%__MODULE__{} = state, paths, from) do + this_node = inspect(Node.self()) + + args = [ + "--name", + Project.node_name(state.project), + "--cookie", + state.cookie, + "--no-halt", + "-e", + "Node.connect(#{this_node})" + | path_append_arguments(paths) + ] + + port = RemoteControl.Port.open_elixir(state.project, args: args) + + %{state | port: port, started_by: from} + end + + def stop(%__MODULE__{} = state, from, stop_timeout) do + project_rpc(state, System, :stop) + %{state | stopped_by: from, stop_timeout: stop_timeout, status: :stopping} + end + + def halt(%__MODULE__{} = state) do + project_rpc(state, System, :halt) + %{state | status: :stopped} + end + + def on_nodeup(%__MODULE__{} = state, node_name) do + if node_name == Project.node_name(state.project) do + {pid, _ref} = state.started_by + Process.monitor(pid) + GenServer.reply(state.started_by, :ok) + + %{state | status: :started} + else + state + end + end + + def on_nodedown(%__MODULE__{} = state, node_name) do + if node_name == Project.node_name(state.project) do + maybe_reply_to_stopper(state) + {:shutdown, %{state | status: :stopped}} + else + :continue + end + end + + def maybe_reply_to_stopper(%State{stopped_by: stopped_by} = state) + when is_tuple(stopped_by) do + GenServer.reply(state.stopped_by, :ok) + end + + def maybe_reply_to_stopper(%State{}), do: :ok + + def on_monitored_dead(%__MODULE__{} = state) do + if project_rpc(state, Node, :alive?) do + halt(state) + else + %{state | status: :stopped} + end + end + + defp path_append_arguments(paths) do + Enum.flat_map(paths, fn path -> + ["-pa", Path.expand(path)] + end) + end + + defp project_rpc(%__MODULE__{} = state, module, function, args \\ []) do + state.project + |> Project.node_name() + |> :rpc.call(module, function, args) + end + end + + alias Lexical.Document + alias Lexical.RemoteControl.ProjectNodeSupervisor + use GenServer + + def start(project, paths) do + node_name = Project.node_name(project) + bootstrap_args = [project, Document.Store.entropy(), all_app_configs()] + + with {:ok, node_pid} <- ProjectNodeSupervisor.start_project_node(project), + :ok <- start_node(project, paths), + :ok <- :rpc.call(node_name, RemoteControl.Bootstrap, :init, bootstrap_args) do + {:ok, node_pid} + end + end + + @stop_timeout 1_000 + + def stop(%Project{} = project, stop_timeout \\ @stop_timeout) do + project + |> name() + |> GenServer.call({:stop, stop_timeout}, stop_timeout + 100) + end + + def child_spec(%Project{} = project) do + %{ + id: name(project), + start: {__MODULE__, :start_link, [project]}, + restart: :transient + } + end + + def start_link(%Project{} = project) do + state = State.new(project) + GenServer.start_link(__MODULE__, state, name: name(project)) + end + + @start_timeout 3_000 + + defp start_node(project, paths) do + project + |> name() + |> GenServer.call({:start, paths}, @start_timeout + 500) + end + + @impl GenServer + def init(state) do + Process.flag(:trap_exit, true) + {:ok, state} + end + + @impl true + def handle_call({:start, paths}, from, %State{} = state) do + :ok = :net_kernel.monitor_nodes(true, node_type: :visible) + Process.send_after(self(), :maybe_start_timeout, @start_timeout) + state = State.start(state, paths, from) + {:noreply, state} + end + + @impl true + def handle_call({:stop, stop_timeout}, from, %State{} = state) do + state = State.stop(state, from, stop_timeout) + {:noreply, state, stop_timeout} + end + + @impl true + def handle_info({:nodeup, node, _}, %State{} = state) do + state = State.on_nodeup(state, node) + {:noreply, state} + end + + @impl true + def handle_info(:maybe_start_timeout, %State{status: :started} = state) do + {:noreply, state} + end + + @impl true + def handle_info(:maybe_start_timeout, %State{} = state) do + GenServer.reply(state.started_by, {:error, :start_timeout}) + {:stop, :start_timeout, nil} + end + + @impl true + def handle_info({:nodedown, node_name, _}, %State{} = state) do + case State.on_nodedown(state, node_name) do + {:shutdown, new_state} -> + {:stop, :shutdown, new_state} + + :continue -> + {:noreply, state} + end + end + + @impl true + def handle_info({:DOWN, _ref, :process, _object, _reason}, %State{} = state) do + state = State.on_monitored_dead(state) + {:stop, :shutdown, state} + end + + @impl true + def handle_info({:EXIT, port, reason}, %State{port: port} = state) do + Logger.info("Port #{inspect(port)} has exited due to: #{inspect(reason)}") + {:noreply, %State{state | port: nil}} + end + + @impl true + def handle_info({:EXIT, port, _}, state) when is_port(port) do + {:noreply, state} + end + + @impl true + def handle_info(:timeout, %State{} = state) do + state = State.halt(state) + State.maybe_reply_to_stopper(state) + {:stop, :shutdown, state} + end + + @impl true + def handle_info({_port, {:data, _message}}, %State{} = state) do + {:noreply, state} + end + + @impl true + def handle_info(msg, %State{} = state) do + Logger.warning("Received unexpected message #{inspect(msg)}") + {:noreply, state} + end + + def name(%Project{} = project) do + :"#{Project.name(project)}::node_process" + end + + @deps_apps Mix.Project.deps_apps() + defp all_app_configs do + Enum.map(@deps_apps, fn app_name -> + {app_name, Application.get_all_env(app_name)} + end) + end +end diff --git a/engine/lib/engine/project_node_supervisor.ex b/engine/lib/engine/project_node_supervisor.ex new file mode 100644 index 00000000..f79cb9ae --- /dev/null +++ b/engine/lib/engine/project_node_supervisor.ex @@ -0,0 +1,27 @@ +defmodule Lexical.RemoteControl.ProjectNodeSupervisor do + alias Lexical.Project + alias Lexical.RemoteControl.ProjectNode + use DynamicSupervisor + + @dialyzer {:no_return, start_link: 1} + + def child_spec(%Project{} = project) do + %{ + id: {__MODULE__, Project.name(project)}, + start: {__MODULE__, :start_link, [project]} + } + end + + def start_link(%Project{} = project) do + DynamicSupervisor.start_link(__MODULE__, project, name: __MODULE__, strategy: :one_for_one) + end + + def start_project_node(%Project{} = project) do + DynamicSupervisor.start_child(__MODULE__, ProjectNode.child_spec(project)) + end + + @impl true + def init(_init_arg) do + DynamicSupervisor.init(strategy: :one_for_one) + end +end diff --git a/engine/lib/engine/search/fuzzy.ex b/engine/lib/engine/search/fuzzy.ex new file mode 100644 index 00000000..43681828 --- /dev/null +++ b/engine/lib/engine/search/fuzzy.ex @@ -0,0 +1,386 @@ +defmodule Lexical.RemoteControl.Search.Fuzzy do + @moduledoc """ + A backend for fuzzy matching + + This is a storage module that allows you to map keys to multiple values in two ways. + + Values are grouped by their `subject`, which is a string that enables fuzzy matching. They can also be grouped + by a `grouping key` that allows for grouping by an arbitrary value. + + For both cases, multiple values can exist under the same key, and when searching, all values under the key are + returned. + """ + + alias Lexical.Project + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Search.Fuzzy.Scorer + alias Lexical.RemoteControl.Search.Indexer.Entry + import Record + + defstruct subject_to_values: %{}, + grouping_key_to_values: %{}, + preprocessed_subjects: %{}, + mapper: nil, + filter_fn: nil, + subject_converter: nil + + defrecordp :mapped, + application: nil, + grouping_key: nil, + subject: nil, + subtype: nil, + type: nil, + value: nil + + @type subject :: String.t() + @type extracted_subject :: term() + @type grouping_key :: term() + @type value :: term() + @type extracted_subject_grouping_key_value :: {extracted_subject(), grouping_key(), value()} + @type mapper :: (term -> extracted_subject_grouping_key_value) + @type subject_converter :: (extracted_subject() -> subject()) + + @opaque t :: %__MODULE__{ + subject_to_values: %{subject() => [value()]}, + grouping_key_to_values: %{Path.t() => [value()]}, + preprocessed_subjects: %{subject() => tuple()}, + mapper: mapper(), + subject_converter: subject_converter() + } + + @spec from_entries([Entry.t()]) :: t + def from_entries(entries) do + mapper = default_mapper() + + new(entries, mapper, &stringify/1, true) + end + + def from_backend(backend) do + mapper = default_mapper() + + mapped_items = + backend.reduce([], fn + %Entry{subtype: :definition} = entry, acc -> [mapper.(entry) | acc] + _, acc -> acc + end) + + new(mapped_items, mapper, &stringify/1, false) + end + + @doc """ + Creates a new fuzzy matcher. + + Items in the enumerable first argument will have the mapper function applied to them. + For each tuple returned, the first element will then have the subject converter applied. + This will produce a subject, which is what the `match/2` function uses for fuzzy matching. + """ + @spec new(Enumerable.t(), mapper(), subject_converter(), boolean()) :: t + def new(items, mapper, subject_converter, map_items?) do + filter_fun = build_filter_fn() + + mapped_items = + if map_items? do + items + |> Stream.map(mapper) + |> Enum.filter(filter_fun) + else + Enum.filter(items, filter_fun) + end + + extract_and_fix_subject = fn mapped() = mapped -> subject_converter.(mapped) end + extract_value = fn mapped(value: value) -> value end + + subject_to_values = Enum.group_by(mapped_items, extract_and_fix_subject, extract_value) + + extract_grouping_key = fn mapped(grouping_key: grouping_key) -> grouping_key end + + grouping_key_to_values = Enum.group_by(mapped_items, extract_grouping_key, extract_value) + + preprocessed_subjects = + subject_to_values + |> Map.keys() + |> Map.new(fn subject -> {subject, Scorer.preprocess(subject)} end) + + %__MODULE__{ + filter_fn: filter_fun, + grouping_key_to_values: grouping_key_to_values, + mapper: mapper, + preprocessed_subjects: preprocessed_subjects, + subject_converter: subject_converter, + subject_to_values: subject_to_values + } + end + + @doc """ + Applies fuzzy matching to the pattern. + + Values that match will be aggregated and returned sorted + in descending order of the match relevance. Items at the beginning of the list + will have a higher score than items at the end. + """ + @spec match(t(), String.t()) :: [Entry.entry_id()] + def match(%__MODULE__{} = fuzzy, pattern) do + fuzzy.subject_to_values + |> Stream.map(fn {subject, ids} -> + case score(fuzzy, subject, pattern) do + {:ok, score} -> + {score, ids} + + :error -> + nil + end + end) + |> Stream.reject(&is_nil/1) + |> Enum.sort_by(&elem(&1, 0), :desc) + |> Enum.flat_map(&elem(&1, 1)) + end + + @doc """ + Adds a single item or a list of items to the fuzzy instance. + """ + @spec add(t, term | [term]) :: t + def add(%__MODULE__{} = fuzzy, items) when is_list(items) do + Enum.reduce(items, fuzzy, fn entry, fuzzy -> + add(fuzzy, entry) + end) + end + + def add(%__MODULE__{} = fuzzy, item) do + mapped_item = fuzzy.mapper.(item) + + if fuzzy.filter_fn.(mapped_item) do + subject = fuzzy.subject_converter.(mapped_item) + mapped(grouping_key: grouping_key, value: value) = mapped_item + + updated_grouping_key_to_values = + Map.update(fuzzy.grouping_key_to_values, grouping_key, [value], fn old_ids -> + [value | old_ids] + end) + + updated_subject_to_values = + Map.update(fuzzy.subject_to_values, subject, [value], fn old_ids -> + [value | old_ids] + end) + + updated_preprocessed_subjects = + Map.put_new_lazy(fuzzy.preprocessed_subjects, subject, fn -> + Scorer.preprocess(subject) + end) + + %__MODULE__{ + fuzzy + | grouping_key_to_values: updated_grouping_key_to_values, + subject_to_values: updated_subject_to_values, + preprocessed_subjects: updated_preprocessed_subjects + } + else + fuzzy + end + end + + @doc """ + Returns true if the fuzzy instance has the specified grouping_key + """ + @spec has_grouping_key?(t, grouping_key()) :: boolean + def has_grouping_key?(%__MODULE__{} = fuzzy, grouping_key) do + Map.has_key?(fuzzy.grouping_key_to_values, grouping_key) + end + + @doc """ + Returns true if the fuzzy instance has the specified subject. + + If the subject is a string, the conversion function passed into the + constructor will be applied to the `subject` parameter. + """ + @spec has_subject?(t, extracted_subject() | subject()) :: boolean + def has_subject?(%__MODULE__{} = fuzzy, subject) when is_binary(subject) do + Map.has_key?(fuzzy.subject_to_values, subject) + end + + def has_subject?(%__MODULE__{} = fuzzy, subject) do + has_subject?(fuzzy, fuzzy.subject_converter.(subject)) + end + + @spec delete_grouping_key(t, grouping_key()) :: t + def delete_grouping_key(%__MODULE__{} = fuzzy, grouping_key) do + values = Map.get(fuzzy.grouping_key_to_values, grouping_key, []) + fuzzy = drop_values(fuzzy, values) + + %__MODULE__{ + fuzzy + | grouping_key_to_values: Map.delete(fuzzy.grouping_key_to_values, grouping_key) + } + end + + @spec drop_values(t, [value()]) :: t + def drop_values(%__MODULE__{} = fuzzy, []) do + # a little optimization; drop_values is pretty expensive, and it's used in + # delete_grouping_key. If there is nothing to delete, we should just return the fuzzy + # unmodified. + fuzzy + end + + @doc """ + Removes all the given values from the data structure. + + If dropping the values results in a subject or grouping key having no entries in the data structure, + the subject or grouping key is also removed. + """ + def drop_values(%__MODULE__{} = fuzzy, values) do + values_mapset = MapSet.new(values) + + reject_values = fn {subject, values} -> + {subject, Enum.reject(values, &MapSet.member?(values_mapset, &1))} + end + + empty_values? = fn + {_, []} -> true + {_, _} -> false + end + + subject_to_values = + fuzzy.subject_to_values + |> Stream.map(reject_values) + |> Stream.reject(empty_values?) + |> Map.new() + + all_subjects = + subject_to_values + |> Map.keys() + |> MapSet.new() + + grouping_key_to_values = + fuzzy.grouping_key_to_values + |> Stream.map(reject_values) + |> Stream.reject(empty_values?) + |> Map.new() + + preprocessed_subjects = + fuzzy.preprocessed_subjects + |> Stream.filter(fn {subject, _} -> + MapSet.member?(all_subjects, subject) + end) + |> Map.new() + + %__MODULE__{ + fuzzy + | subject_to_values: subject_to_values, + grouping_key_to_values: grouping_key_to_values, + preprocessed_subjects: preprocessed_subjects + } + end + + defp score(%__MODULE__{} = fuzzy, subject, pattern) do + with {:ok, preprocessed} <- Map.fetch(fuzzy.preprocessed_subjects, subject), + {true, score} <- Scorer.score(preprocessed, pattern) do + {:ok, score} + else + _ -> + :error + end + end + + defp stringify(mapped(type: {:function, _}, subject: subject)) do + subject + |> String.split(".") + |> List.last() + |> String.split("/") + |> List.first() + end + + defp stringify(mapped(type: :module, subject: module_name)) do + Lexical.Formats.module(module_name) + end + + defp stringify(mapped(subject: string)) when is_binary(string) do + string + end + + defp stringify(mapped(subject: thing)) do + inspect(thing) + end + + defp stringify(thing) when is_binary(thing) do + thing + end + + defp stringify(atom) when is_atom(atom) do + cond do + function_exported?(atom, :__info__, 1) -> + Lexical.Formats.module(atom) + + function_exported?(atom, :module_info, 0) -> + Lexical.Formats.module(atom) + + true -> + inspect(atom) + end + end + + defp stringify(thing) do + inspect(thing) + end + + defp default_mapper do + fn %Entry{} = entry -> + mapped( + application: entry.application, + grouping_key: entry.path, + subject: entry.subject, + subtype: entry.subtype, + type: entry.type, + value: entry.id + ) + end + end + + defp build_filter_fn do + deps_directories = + if Mix.Project.get() do + deps_roots() + else + {:ok, deps_roots} = + RemoteControl.Mix.in_project(fn _ -> + deps_roots() + end) + + deps_roots + end + + fn + mapped(subtype: :definition, grouping_key: path) -> + # if we don't have an app name, just make sure we're not + # in what looks like a deps directory + not Enum.any?(deps_directories, &String.starts_with?(path, &1)) + + _ -> + false + end + end + + defp deps_roots do + deps_roots(RemoteControl.get_project()) + end + + defp deps_roots(%Project{mix_project?: true} = project) do + # Note: This function assumes that the deps directories for all + # found projects is `deps`. Projects may override this directory + # and lexical won't understand this. This was done because loading + # each sub-project is expensive and changes our global directory. + + [Project.root_path(project), "**", "mix.exs"] + |> Path.join() + |> Path.wildcard() + |> Enum.map(fn relative_mix_path -> + relative_mix_path + |> Path.absname() + |> Path.dirname() + |> Path.join("deps") + end) + |> Enum.filter(&File.exists?/1) + end + + defp deps_roots(_) do + [] + end +end diff --git a/engine/lib/engine/search/fuzzy/scorer.ex b/engine/lib/engine/search/fuzzy/scorer.ex new file mode 100644 index 00000000..03b1903e --- /dev/null +++ b/engine/lib/engine/search/fuzzy/scorer.ex @@ -0,0 +1,310 @@ +defmodule Lexical.RemoteControl.Search.Fuzzy.Scorer do + @moduledoc """ + Scores a match based on heuristics. + + The goal of this module is to have a quick to build and fast to query fuzzy matching system. + + Matches match a subject based on a pattern given by the user. A string is considered to match + if the subject contains all of the pattern's characters, in any order. However, patterns + can be boosted based on heuristics. + + The heuristics boost: + 1. Larger patterns + 2. Patterns that match more consecutive characters + 3. Patterns that match the beginning of the subject + 4. Patterns that match the case of the subject + 5. Patterns that match the tail of a subject starting at the last period + + Based loosely on https://medium.com/@Srekel/implementing-a-fuzzy-search-algorithm-for-the-debuginator-cacc349e6c55 + """ + defstruct match?: false, + index: 0, + matched_character_positions: [] + + import Record + + defrecord :subject, graphemes: nil, normalized: nil, period_positions: [-1] + + @typedoc "A match score. Higher numbers mean a more relevant match." + @type score :: integer + @type score_result :: {match? :: boolean(), score} + @type subject :: term() + @type pattern :: String.t() + @type preprocessed :: + record(:subject, graphemes: tuple(), normalized: String.t()) + @non_match_score -5000 + + @doc """ + Pre-processes a subject into separate parts that will be helpful during the search phase. + Pre-processing allows us to do the work of extracting important metadata per-subject + rather than on every request. + """ + @spec preprocess(subject()) :: preprocessed() + def preprocess(subject) when is_binary(subject) do + graphemes = + subject + |> String.graphemes() + |> List.to_tuple() + + normalized = normalize(subject) + + subject( + graphemes: graphemes, + normalized: normalized, + period_positions: period_positions(normalized) + ) + end + + def preprocess(subject) do + subject + |> inspect() + |> preprocess() + end + + @doc """ + Scores the pattern based on the subject + + Returns a two-element tuple, where the first element is a boolean representing if the + pattern matches the subject. The second element is the score of the match. Higher + scores mean a better match. Scores can be negative. + """ + @spec score(subject(), pattern()) :: score_result() + def score(subject, pattern) when is_binary(subject) do + subject + |> preprocess() + |> score(pattern) + end + + def score(subject(normalized: normalized) = subject, pattern) do + normalized_pattern = normalize(pattern) + + case collect_scores(normalized, normalized_pattern) do + [] -> + {false, @non_match_score} + + elems -> + max_score = + elems + |> Enum.map(&calculate_score(&1, subject, pattern)) + |> Enum.max() + + {true, max_score} + end + end + + defp collect_scores(normalized, normalized_pattern, starting_index \\ 0, acc \\ []) + + defp collect_scores(normalized_subject, normalized_pattern, starting_index, scores) do + # we collect scores because it's possible that a better match occurs later + # in the subject, and if we start peeling off characters greedily, we'll miss + # it. This is more expensive, but it's still pretty quick. + + initial_score = %__MODULE__{index: starting_index} + + case do_score(normalized_subject, normalized_pattern, initial_score) do + %__MODULE__{match?: true, matched_character_positions: [pos | _]} = score -> + slice_start = pos + 1 + next_index = starting_index + slice_start + subject_substring = String.slice(normalized_subject, slice_start..-1//1) + scores = [score | scores] + collect_scores(subject_substring, normalized_pattern, next_index, scores) + + _ -> + scores + end + end + + # out of pattern, we have a match. + defp do_score(_, <<>>, %__MODULE__{} = score) do + %__MODULE__{ + score + | match?: true, + matched_character_positions: Enum.reverse(score.matched_character_positions) + } + end + + # we're out of subject, but we still have pattern, no match + defp do_score(<<>>, _, %__MODULE__{} = score) do + %__MODULE__{ + score + | matched_character_positions: Enum.reverse(score.matched_character_positions) + } + end + + defp do_score( + <>, + <>, + %__MODULE__{} = score + ) do + score = + score + |> add_to_list(:matched_character_positions, score.index) + |> increment(:index) + + do_score(subject_rest, pattern_rest, score) + end + + defp do_score(<<_unmatched::utf8, subject_rest::binary>>, pattern, %__MODULE__{} = score) do + score = increment(score, :index) + + do_score(subject_rest, pattern, score) + end + + defp increment(%__MODULE__{} = score, field_name) do + Map.update!(score, field_name, &(&1 + 1)) + end + + defp add_to_list(%__MODULE__{} = score, field_name, value) do + Map.update(score, field_name, [value], &[value | &1]) + end + + defp calculate_score(%__MODULE__{match?: false}, _, _) do + @non_match_score + end + + defp calculate_score(%__MODULE__{} = score, subject(graphemes: graphemes) = subject, pattern) do + pattern_length = String.length(pattern) + + {consecutive_count, consecutive_bonus} = + consecutive_match_boost(score.matched_character_positions) + + match_amount_boost = consecutive_count * pattern_length + + match_boost = tail_match_boost(score, subject, pattern_length) + + camel_case_boost = camel_case_boost(score.matched_character_positions, subject) + + mismatched_penalty = mismatched_penalty(score.matched_character_positions) + + incompleteness_penalty = tuple_size(graphemes) - length(score.matched_character_positions) + + consecutive_bonus + match_boost + camel_case_boost + + match_amount_boost - mismatched_penalty - incompleteness_penalty + end + + defp normalize(string) do + String.downcase(string) + end + + @tail_match_boost 55 + + defp tail_match_boost( + %__MODULE__{} = score, + subject(graphemes: graphemes, period_positions: period_positions), + pattern_length + ) do + [first_match_position | _] = score.matched_character_positions + + match_end = first_match_position + pattern_length + subject_length = tuple_size(graphemes) + + if MapSet.member?(period_positions, first_match_position - 1) and match_end == subject_length do + # reward a complete match at the end of the last period. This is likely a module + # and the pattern matches the most local parts + @tail_match_boost + else + 0 + end + end + + @consecutive_character_bonus 15 + + def consecutive_match_boost(matched_positions) do + # This function checks for consecutive matched characters, and + # makes matches with more consecutive matched characters worth more. + # This means if I type En, it will match Enum more than it will match + # Something + + max_streak = + matched_positions + |> Enum.reduce([[]], fn + current, [[last | streak] | rest] when last == current - 1 -> + [[current, last | streak] | rest] + + current, acc -> + [[current] | acc] + end) + |> Enum.max_by(&length/1) + + streak_length = length(max_streak) + {streak_length, @consecutive_character_bonus * streak_length} + end + + @mismatched_chracter_penalty 5 + + def mismatched_penalty(matched_positions) do + {penalty, _} = + matched_positions + |> Enum.reduce({0, -1}, fn + matched_position, {0, _} -> + # only start counting the penalty after the first match, + # otherwise we will inadvertently penalize matches deeper in the string + {0, matched_position} + + matched_position, {penalty, last_match} -> + distance = matched_position - last_match + + {penalty + distance * @mismatched_chracter_penalty, matched_position} + end) + + penalty + end + + @camel_case_boost 5 + defp camel_case_boost(matched_positions, subject(graphemes: graphemes)) do + graphemes + |> Tuple.to_list() + |> camel_positions() + |> Enum.reduce(0, fn position, score -> + if position in matched_positions do + score + @camel_case_boost + else + score + end + end) + end + + defp camel_positions(graphemes) do + camel_positions(graphemes, {nil, :lower}, 0, []) + end + + defp camel_positions([], _, _, positions) do + Enum.reverse(positions) + end + + defp camel_positions([grapheme | rest], {_last_char, :lower}, position, positions) do + case case_of(grapheme) do + :lower -> + camel_positions(rest, {grapheme, :lower}, position + 1, positions) + + :upper -> + camel_positions(rest, {grapheme, :upper}, position + 1, [position | positions]) + end + end + + defp camel_positions([grapheme | rest], {_last_char, :upper}, position, positions) do + camel_positions(rest, {grapheme, case_of(grapheme)}, position + 1, positions) + end + + defp case_of(grapheme) do + if String.downcase(grapheme) == grapheme do + :lower + else + :upper + end + end + + defp period_positions(string) do + period_positions(string, 0, [-1]) + end + + defp period_positions(<<>>, _, positions), do: MapSet.new(positions) + + defp period_positions(<<".", rest::binary>>, position, positions) do + period_positions(rest, position + 1, [position | positions]) + end + + defp period_positions(<<_::utf8, rest::binary>>, position, positions) do + period_positions(rest, position + 1, positions) + end +end diff --git a/engine/lib/engine/search/indexer.ex b/engine/lib/engine/search/indexer.ex new file mode 100644 index 00000000..c5dddaed --- /dev/null +++ b/engine/lib/engine/search/indexer.ex @@ -0,0 +1,211 @@ +defmodule Lexical.RemoteControl.Search.Indexer do + alias Lexical.Identifier + alias Lexical.ProcessCache + alias Lexical.Project + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Progress + alias Lexical.RemoteControl.Search.Indexer + alias Lexical.RemoteControl.Search.Indexer.Entry + + require ProcessCache + + @indexable_extensions "*.{ex,exs}" + + def create_index(%Project{} = project) do + ProcessCache.with_cleanup do + deps_dir = deps_dir() + + entries = + project + |> indexable_files() + |> async_chunks(&index_path(&1, deps_dir)) + + {:ok, entries} + end + end + + def update_index(%Project{} = project, backend) do + ProcessCache.with_cleanup do + do_update_index(project, backend) + end + end + + defp do_update_index(%Project{} = project, backend) do + path_to_ids = + backend.reduce(%{}, fn + %Entry{path: path} = entry, path_to_ids when is_integer(entry.id) -> + Map.update(path_to_ids, path, entry.id, &max(&1, entry.id)) + + _entry, path_to_ids -> + path_to_ids + end) + + project_files = + project + |> indexable_files() + |> MapSet.new() + + previously_indexed_paths = MapSet.new(path_to_ids, fn {path, _} -> path end) + + new_paths = MapSet.difference(project_files, previously_indexed_paths) + + {paths_to_examine, paths_to_delete} = + Enum.split_with(path_to_ids, fn {path, _} -> File.regular?(path) end) + + changed_paths = + for {path, id} <- paths_to_examine, + newer_than?(path, id) do + path + end + + paths_to_delete = Enum.map(paths_to_delete, &elem(&1, 0)) + + paths_to_reindex = changed_paths ++ Enum.to_list(new_paths) + + entries = async_chunks(paths_to_reindex, &index_path(&1, deps_dir())) + + {:ok, entries, paths_to_delete} + end + + defp index_path(path, deps_dir) do + with {:ok, contents} <- File.read(path), + {:ok, entries} <- Indexer.Source.index(path, contents) do + Enum.filter(entries, fn entry -> + if contained_in?(path, deps_dir) do + entry.subtype == :definition + else + true + end + end) + else + _ -> + [] + end + end + + # 128 K blocks indexed lexical in 5.3 seconds + @bytes_per_block 1024 * 128 + defp async_chunks(file_paths, processor, timeout \\ :infinity) do + # this function tries to even out the amount of data processed by + # async stream by making each chunk emitted by the initial stream to + # be roughly equivalent + + # Shuffling the results helps speed in some projects, as larger files tend to clump + # together, like when there are auto-generated elixir modules. + paths_to_sizes = + file_paths + |> path_to_sizes() + |> Enum.shuffle() + + path_to_size_map = Map.new(paths_to_sizes) + + total_bytes = paths_to_sizes |> Enum.map(&elem(&1, 1)) |> Enum.sum() + + {on_update_progess, on_complete} = Progress.begin_percent("Indexing source code", total_bytes) + + initial_state = {0, []} + + chunk_fn = fn {path, file_size}, {block_size, paths} -> + new_block_size = file_size + block_size + new_paths = [path | paths] + + if new_block_size >= @bytes_per_block do + {:cont, new_paths, initial_state} + else + {:cont, {new_block_size, new_paths}} + end + end + + after_fn = fn + {_, []} -> + {:cont, []} + + {_, paths} -> + {:cont, paths, []} + end + + paths_to_sizes + |> Stream.chunk_while(initial_state, chunk_fn, after_fn) + |> Task.async_stream( + fn chunk -> + block_bytes = chunk |> Enum.map(&Map.get(path_to_size_map, &1)) |> Enum.sum() + result = Enum.map(chunk, processor) + on_update_progess.(block_bytes, "Indexing") + result + end, + timeout: timeout + ) + |> Stream.flat_map(fn + {:ok, entry_chunks} -> entry_chunks + _ -> [] + end) + # The next bit is the only way i could figure out how to + # call complete once the stream was realized + |> Stream.transform( + fn -> nil end, + fn chunk_items, acc -> + # By the chunk items list directly, each transformation + # will flatten the resulting steam + {chunk_items, acc} + end, + fn _acc -> + on_complete.() + end + ) + end + + defp path_to_sizes(paths) do + Enum.reduce(paths, [], fn file_path, acc -> + case File.stat(file_path) do + {:ok, %File.Stat{} = stat} -> + [{file_path, stat.size} | acc] + + _ -> + acc + end + end) + end + + defp newer_than?(path, entry_id) do + case stat(path) do + {:ok, %File.Stat{} = stat} -> + stat.mtime > Identifier.to_erl(entry_id) + + _ -> + false + end + end + + def indexable_files(%Project{} = project) do + root_dir = Project.root_path(project) + build_dir = build_dir() + + [root_dir, "**", @indexable_extensions] + |> Path.join() + |> Path.wildcard() + |> Enum.reject(&contained_in?(&1, build_dir)) + end + + # stat(path) is here for testing so it can be mocked + defp stat(path) do + File.stat(path) + end + + defp contained_in?(file_path, possible_parent) do + String.starts_with?(file_path, possible_parent) + end + + defp deps_dir do + case RemoteControl.Mix.in_project(&Mix.Project.deps_path/0) do + {:ok, path} -> path + _ -> Mix.Project.deps_path() + end + end + + defp build_dir do + case RemoteControl.Mix.in_project(&Mix.Project.build_path/0) do + {:ok, path} -> path + _ -> Mix.Project.build_path() + end + end +end diff --git a/engine/lib/engine/search/indexer/entry.ex b/engine/lib/engine/search/indexer/entry.ex new file mode 100644 index 00000000..cb17f9f0 --- /dev/null +++ b/engine/lib/engine/search/indexer/entry.ex @@ -0,0 +1,155 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Entry do + @type function_type :: :public | :private | :delegated | :usage + @type protocol_type :: :implementation | :definition + + @type entry_type :: + :ex_unit_describe + | :ex_unit_test + | :module + | :module_attribute + | :struct + | :variable + | {:protocol, protocol_type()} + | {:function, function_type()} + + @type subject :: String.t() + @type entry_subtype :: :reference | :definition + @type version :: String.t() + @type entry_id :: pos_integer() | nil + @type block_id :: pos_integer() | :root + @type subject_query :: subject() | :_ + @type entry_type_query :: entry_type() | :_ + @type entry_subtype_query :: entry_subtype() | :_ + @type constraint :: {:type, entry_type_query()} | {:subtype, entry_subtype_query()} + @type constraints :: [constraint()] + + defstruct [ + :application, + :id, + :block_id, + :block_range, + :path, + :range, + :subject, + :subtype, + :type, + :metadata + ] + + @type t :: %__MODULE__{ + application: module(), + subject: subject(), + block_id: block_id(), + block_range: Lexical.Document.Range.t() | nil, + path: Path.t(), + range: Lexical.Document.Range.t(), + subtype: entry_subtype(), + type: entry_type(), + metadata: nil | map() + } + @type datetime_format :: :erl | :unix | :datetime + @type date_type :: :calendar.datetime() | integer() | DateTime.t() + + alias Lexical.Identifier + alias Lexical.RemoteControl.Search.Indexer.Source.Block + alias Lexical.StructAccess + + use StructAccess + + defguard is_structure(entry) when entry.type == :metadata and entry.subtype == :block_structure + defguard is_block(entry) when entry.id == entry.block_id + + @doc """ + Creates a new entry by copying the passed-in entry. + + The returned entry will have the same fields set as the one passed in, + but a different id. + You can also pass in a keyword list of overrides, which will overwrit values in + the returned struct. + """ + def copy(%__MODULE__{} = orig, overrides \\ []) when is_list(overrides) do + %__MODULE__{orig | id: Identifier.next_global!()} + |> struct(overrides) + end + + def block_structure(path, structure) do + %__MODULE__{ + path: path, + subject: structure, + type: :metadata, + subtype: :block_structure + } + end + + def reference(path, %Block{} = block, subject, type, range, application) do + new(path, Identifier.next_global!(), block.id, subject, type, :reference, range, application) + end + + def definition(path, %Block{} = block, subject, type, range, application) do + new(path, Identifier.next_global!(), block.id, subject, type, :definition, range, application) + end + + def block_definition( + path, + %Block{} = block, + subject, + type, + block_range, + detail_range, + application + ) do + definition = + definition( + path, + block.id, + block.parent_id, + subject, + type, + detail_range, + application + ) + + %__MODULE__{definition | block_range: block_range} + end + + defp definition(path, id, block_id, subject, type, range, application) do + new(path, id, block_id, subject, type, :definition, range, application) + end + + defp new(path, id, block_id, subject, type, subtype, range, application) do + %__MODULE__{ + application: application, + block_id: block_id, + id: id, + path: path, + range: range, + subject: subject, + subtype: subtype, + type: type + } + end + + def block?(%__MODULE__{} = entry) do + is_block(entry) + end + + @spec updated_at(t()) :: date_type() + @spec updated_at(t(), datetime_format) :: date_type() + def updated_at(entry, format \\ :erl) + + def updated_at(%__MODULE__{id: id} = entry, format) when is_integer(id) do + case format do + :erl -> Identifier.to_erl(entry.id) + :unix -> Identifier.to_unix(id) + :datetime -> Identifier.to_datetime(id) + end + end + + def updated_at(%__MODULE__{}, _format) do + nil + end + + def put_metadata(%__MODULE__{} = entry, metadata) do + %__MODULE__{entry | metadata: metadata} + end +end diff --git a/engine/lib/engine/search/indexer/extractors/ecto_schema.ex b/engine/lib/engine/search/indexer/extractors/ecto_schema.ex new file mode 100644 index 00000000..fd7ff34b --- /dev/null +++ b/engine/lib/engine/search/indexer/extractors/ecto_schema.ex @@ -0,0 +1,112 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Extractors.EctoSchema do + alias Lexical.Ast + alias Lexical.Document.Position + alias Lexical.RemoteControl.Analyzer + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Indexer.Metadata + alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + + def extract( + {:schema, meta, [{:__block__, _, [_source]} | _]} = schema_block, + %Reducer{} = reducer + ) do + case extract_schema_entry(schema_block, meta, reducer) do + {:ok, _} = success -> success + :error -> :ignored + end + end + + def extract( + {:embedded_schema, meta, _} = schema_block, + %Reducer{} = reducer + ) do + case extract_schema_entry(schema_block, meta, reducer) do + {:ok, _} = success -> success + :error -> :ignored + end + end + + @embeds [:embeds_one, :embeds_many] + def extract( + {embed_type, _, [_name, {:__aliases__, _, schema_segments} = schema_module | rest]} = + embed, + %Reducer{} = reducer + ) + when embed_type in @embeds do + document = reducer.analysis.document + position = Reducer.position(reducer) + + with true <- block_form?(rest), + {:ok, module} <- Analyzer.current_module(reducer.analysis, position), + {:ok, expanded} <- Analyzer.expand_alias(schema_segments, reducer.analysis, position), + {:ok, block_range} <- Ast.Range.fetch(embed, document), + {:ok, detail_range} <- Ast.Range.fetch(schema_module, document) do + struct_module = Module.concat(module, expanded) + + definition = + Entry.block_definition( + document.path, + Reducer.current_block(reducer), + struct_module, + :struct, + block_range, + detail_range, + Application.get_application(struct_module) + ) + + {:ok, definition} + else + _ -> + :ignored + end + end + + def extract(_ast, _reducer) do + :ignored + end + + defp extract_schema_entry(schema_block, meta, %Reducer{} = reducer) do + document = reducer.analysis.document + position = Reducer.position(reducer) + + with true <- defines_schema?(reducer, position), + {:ok, current_module} <- Analyzer.current_module(reducer.analysis, position), + {do_line, do_column} <- Metadata.position(meta, :do), + {:ok, range} <- Ast.Range.fetch(schema_block, document) do + detail_range = put_in(range.end, Position.new(document, do_line, do_column + 2)) + + definition_entry = + Entry.block_definition( + document.path, + Reducer.current_block(reducer), + current_module, + :struct, + range, + detail_range, + Application.get_application(current_module) + ) + + {:ok, definition_entry} + else + _ -> + :error + end + end + + defp defines_schema?(%Reducer{} = reducer, %Position{} = position) do + Ecto.Schema in Analyzer.uses_at(reducer.analysis, position) + end + + defp block_form?(ast) do + {_, result} = + Macro.prewalk(ast, false, fn + {:__block__, _, [:do]}, false -> + {nil, true} + + ast, acc -> + {ast, acc} + end) + + result + end +end diff --git a/engine/lib/engine/search/indexer/extractors/ex_unit.ex b/engine/lib/engine/search/indexer/extractors/ex_unit.ex new file mode 100644 index 00000000..d36f73ab --- /dev/null +++ b/engine/lib/engine/search/indexer/extractors/ex_unit.ex @@ -0,0 +1,128 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Extractors.ExUnit do + alias Lexical.Ast + alias Lexical.Ast.Analysis + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.Formats + alias Lexical.RemoteControl.Analyzer + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Indexer.Metadata + alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + + require Logger + + # setup block i.e. setup do... or setup arg do... + def extract({setup_fn, _, args} = setup, %Reducer{} = reducer) + when setup_fn in [:setup, :setup_all] and length(args) > 0 do + {:ok, module} = Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) + arity = arity_for(args) + subject = Formats.mfa(module, setup_fn, arity) + setup_type = :"ex_unit_#{setup_fn}" + + entry = + case Metadata.location(setup) do + {:block, _, _, _} -> + block_entry(reducer, setup, setup_type, subject) + + {:expression, _} -> + expression_entry(reducer, setup, setup_type, subject) + end + + {:ok, entry} + end + + # Test block test "test name" do ... or test "test name", arg do + def extract({:test, _, [{_, _, [test_name]} | _] = args} = test, %Reducer{} = reducer) + when is_binary(test_name) do + {:ok, module} = Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) + arity = arity_for(args) + module_name = Formats.module(module) + subject = "#{module_name}.[\"#{test_name}\"]/#{arity}" + + entry = + case Metadata.location(test) do + {:block, _, _, _} -> + # a test with a body + block_entry(reducer, test, :ex_unit_test, subject) + + {:expression, _} -> + # a pending test + expression_entry(reducer, test, :ex_unit_test, subject) + end + + {:ok, entry} + end + + # describe blocks + def extract({:describe, _, [{_, _, [describe_name]} | _] = args} = test, %Reducer{} = reducer) do + {:ok, module} = Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) + arity = arity_for(args) + module_name = Formats.module(module) + subject = "#{module_name}[\"#{describe_name}\"]/#{arity}" + + entry = block_entry(reducer, test, :ex_unit_describe, subject) + + {:ok, entry} + end + + def extract(_ign, _) do + :ignored + end + + defp expression_entry(%Reducer{} = reducer, ast, type, subject) do + path = reducer.analysis.document.path + block = Reducer.current_block(reducer) + + {:ok, module} = Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) + app = Application.get_application(module) + detail_range = detail_range(reducer.analysis, ast) + + Entry.definition(path, block, subject, type, detail_range, app) + end + + defp block_entry(%Reducer{} = reducer, ast, type, subject) do + path = reducer.analysis.document.path + block = Reducer.current_block(reducer) + + {:ok, module} = Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) + app = Application.get_application(module) + detail_range = detail_range(reducer.analysis, ast) + block_range = block_range(reducer.analysis, ast) + Entry.block_definition(path, block, subject, type, block_range, detail_range, app) + end + + defp block_range(%Analysis{} = analysis, ast) do + case Ast.Range.fetch(ast, analysis.document) do + {:ok, range} -> range + _ -> nil + end + end + + defp detail_range(%Analysis{} = analysis, ast) do + case Metadata.location(ast) do + {:block, {start_line, start_column}, {do_line, do_column}, _} -> + Range.new( + Position.new(analysis.document, start_line, start_column), + Position.new(analysis.document, do_line, do_column + 2) + ) + + {:expression, {start_line, start_column}} -> + %{end: [line: end_line, column: end_column]} = Sourceror.get_range(ast) + + Range.new( + Position.new(analysis.document, start_line, start_column), + Position.new(analysis.document, end_line, end_column) + ) + end + end + + defp arity_for([{:__block__, _meta, labels}]) do + length(labels) + end + + defp arity_for(args) when is_list(args) do + length(args) + end + + defp arity_for(_), do: 0 +end diff --git a/engine/lib/engine/search/indexer/extractors/function_definition.ex b/engine/lib/engine/search/indexer/extractors/function_definition.ex new file mode 100644 index 00000000..39631474 --- /dev/null +++ b/engine/lib/engine/search/indexer/extractors/function_definition.ex @@ -0,0 +1,110 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Extractors.FunctionDefinition do + alias Lexical.Ast + alias Lexical.Ast.Analysis + alias Lexical.RemoteControl.Analyzer + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + alias Lexical.RemoteControl.Search.Subject + + @function_definitions [:def, :defp] + + def extract({definition, _, [{fn_name, _, args} = def_ast, body]} = ast, %Reducer{} = reducer) + when is_atom(fn_name) and definition in @function_definitions do + with {:ok, detail_range} <- Ast.Range.fetch(def_ast, reducer.analysis.document), + {:ok, module} <- Analyzer.current_module(reducer.analysis, detail_range.start), + {fun_name, arity} when is_atom(fun_name) <- fun_name_and_arity(def_ast) do + entry = + Entry.block_definition( + reducer.analysis.document.path, + Reducer.current_block(reducer), + Subject.mfa(module, fun_name, arity), + type(definition), + block_range(reducer.analysis, ast), + detail_range, + Application.get_application(module) + ) + + {:ok, entry, [args, body]} + else + _ -> + :ignored + end + end + + def extract({:defdelegate, _, [call, _]} = node, %Reducer{} = reducer) do + document = reducer.analysis.document + + with {:ok, detail_range} <- Ast.Range.fetch(call, document), + {:ok, module} <- Analyzer.current_module(reducer.analysis, detail_range.start), + {:ok, {delegated_module, delegated_name, _delegated_arity}} <- + fetch_delegated_mfa(node, reducer.analysis, detail_range.start) do + {delegate_name, args} = Macro.decompose_call(call) + arity = length(args) + metadata = %{original_mfa: Subject.mfa(delegated_module, delegated_name, arity)} + + entry = + Entry.definition( + document.path, + Reducer.current_block(reducer), + Subject.mfa(module, delegate_name, arity), + {:function, :delegate}, + detail_range, + Application.get_application(module) + ) + + {:ok, Entry.put_metadata(entry, metadata)} + else + _ -> + :ignored + end + end + + def extract(_ast, _reducer) do + :ignored + end + + def fetch_delegated_mfa({:defdelegate, _, [call | keywords]}, analysis, position) do + {_, keyword_args} = + Macro.prewalk(keywords, [], fn + {{:__block__, _, [:to]}, {:__aliases__, _, delegated_module}} = ast, acc -> + {ast, Keyword.put(acc, :to, delegated_module)} + + {{:__block__, _, [:as]}, {:__block__, _, [remote_fun_name]}} = ast, acc -> + {ast, Keyword.put(acc, :as, remote_fun_name)} + + ast, acc -> + {ast, acc} + end) + + with {function_name, args} <- Macro.decompose_call(call), + {:ok, module} <- Analyzer.expand_alias(keyword_args[:to], analysis, position) do + function_name = Keyword.get(keyword_args, :as, function_name) + {:ok, {module, function_name, length(args)}} + else + _ -> + :error + end + end + + defp type(:def), do: {:function, :public} + defp type(:defp), do: {:function, :private} + + defp fun_name_and_arity({:when, _, [{fun_name, _, fun_args} | _]}) do + # a function with guards + {fun_name, arity(fun_args)} + end + + defp fun_name_and_arity({fun_name, _, fun_args}) do + {fun_name, arity(fun_args)} + end + + defp arity(nil), do: 0 + defp arity(args) when is_list(args), do: length(args) + + defp block_range(%Analysis{} = analysis, def_ast) do + case Ast.Range.fetch(def_ast, analysis.document) do + {:ok, range} -> range + _ -> nil + end + end +end diff --git a/engine/lib/engine/search/indexer/extractors/function_reference.ex b/engine/lib/engine/search/indexer/extractors/function_reference.ex new file mode 100644 index 00000000..aee640b2 --- /dev/null +++ b/engine/lib/engine/search/indexer/extractors/function_reference.ex @@ -0,0 +1,276 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Extractors.FunctionReference do + alias Lexical.Ast + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Indexer.Extractors.FunctionDefinition + alias Lexical.RemoteControl.Search.Indexer.Metadata + alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + alias Lexical.RemoteControl.Search.Subject + + require Logger + + @excluded_functions_key {__MODULE__, :excluded_functions} + # Dynamic calls using apply apply(Module, :function, [1, 2]) + def extract( + {:apply, apply_meta, + [ + {:__aliases__, _, module}, + {:__block__, _, [function_name]}, + {:__block__, _, + [ + arg_list + ]} + ]}, + %Reducer{} = reducer + ) + when is_list(arg_list) and is_atom(function_name) do + entry = entry(reducer, apply_meta, apply_meta, module, function_name, arg_list) + {:ok, entry, nil} + end + + # Dynamic call via Kernel.apply Kernel.apply(Module, :function, [1, 2]) + def extract( + {{:., _, [{:__aliases__, start_metadata, [:Kernel]}, :apply]}, apply_meta, + [ + {:__aliases__, _, module}, + {:__block__, _, [function_name]}, + {:__block__, _, [arg_list]} + ]}, + %Reducer{} = reducer + ) + when is_list(arg_list) and is_atom(function_name) do + entry = entry(reducer, start_metadata, apply_meta, module, function_name, arg_list) + {:ok, entry, nil} + end + + # remote function OtherModule.foo(:arg), OtherModule.foo() or OtherModule.foo + def extract( + {{:., _, [{:__aliases__, start_metadata, module}, fn_name]}, end_metadata, args}, + %Reducer{} = reducer + ) + when is_atom(fn_name) do + entry = entry(reducer, start_metadata, end_metadata, module, fn_name, args) + + {:ok, entry} + end + + # local function capture &downcase/1 + def extract( + {:/, _, [{fn_name, end_metadata, nil}, {:__block__, arity_meta, [arity]}]}, + %Reducer{} = reducer + ) do + position = Reducer.position(reducer) + + {module, _, _} = + RemoteControl.Analyzer.resolve_local_call(reducer.analysis, position, fn_name, arity) + + entry = entry(reducer, end_metadata, arity_meta, module, fn_name, arity) + {:ok, entry, nil} + end + + # Function capture with arity: &OtherModule.foo/3 + def extract( + {:&, _, + [ + {:/, _, + [ + {{:., _, [{:__aliases__, start_metadata, module}, function_name]}, _, []}, + {:__block__, end_metadata, [arity]} + ]} + ]}, + %Reducer{} = reducer + ) do + entry = entry(reducer, start_metadata, end_metadata, module, function_name, arity) + + # we return nil here to stop analysis from progressing down the syntax tree, + # because if it did, the function head that deals with normal calls will pick + # up the rest of the call and return a reference to MyModule.function/0, which + # is incorrect + {:ok, entry, nil} + end + + def extract({:|>, pipe_meta, [pipe_start, {fn_name, meta, args}]}, %Reducer{}) do + # we're in a pipeline. Skip this node by returning nil, but add a marker to the metadata + # that will be picked up by call_arity. + updated_meta = Keyword.put(meta, :pipeline?, true) + new_pipe = {:|>, pipe_meta, [pipe_start, {fn_name, updated_meta, args}]} + + {:ok, nil, new_pipe} + end + + def extract({:defdelegate, _, _} = ast, %Reducer{} = reducer) do + analysis = reducer.analysis + position = Reducer.position(reducer) + + case FunctionDefinition.fetch_delegated_mfa(ast, analysis, position) do + {:ok, {module, function_name, arity}} -> + entry = + Entry.reference( + analysis.document.path, + Reducer.current_block(reducer), + Lexical.Formats.mfa(module, function_name, arity), + {:function, :usage}, + Ast.Range.get(ast, analysis.document), + Application.get_application(module) + ) + + {:ok, entry, []} + + _ -> + :ignored + end + end + + # local function call foo() foo(arg) + def extract({fn_name, meta, args}, %Reducer{} = reducer) + when is_atom(fn_name) and is_list(args) do + if fn_name in excluded_functions() do + :ignored + else + arity = call_arity(args, meta) + position = Reducer.position(reducer) + + {module, _, _} = + RemoteControl.Analyzer.resolve_local_call(reducer.analysis, position, fn_name, arity) + + entry = entry(reducer, meta, meta, [module], fn_name, args) + + {:ok, entry} + end + end + + def extract(_ast, _reducer) do + :ignored + end + + defp entry( + %Reducer{} = reducer, + start_metadata, + end_metadata, + module, + function_name, + args_arity + ) do + arity = call_arity(args_arity, end_metadata) + block = Reducer.current_block(reducer) + + range = + get_reference_range(reducer.analysis.document, start_metadata, end_metadata, function_name) + + case RemoteControl.Analyzer.expand_alias(module, reducer.analysis, range.start) do + {:ok, module} -> + mfa = Subject.mfa(module, function_name, arity) + + Entry.reference( + reducer.analysis.document.path, + block, + mfa, + {:function, :usage}, + range, + Application.get_application(module) + ) + + _ -> + human_location = Reducer.human_location(reducer) + + Logger.warning( + "Could not expand #{inspect(module)} into an alias. Please report this. (at #{human_location})" + ) + + nil + end + end + + defp get_reference_range(document, start_metadata, end_metadata, function_name) do + {start_line, start_column} = start_position(start_metadata) + start_position = Position.new(document, start_line, start_column) + has_parens? = not Keyword.get(end_metadata, :no_parens, false) + + {end_line, end_column} = + case Metadata.position(end_metadata, :closing) do + {line, column} -> + if has_parens? do + {line, column + 1} + else + {line, column} + end + + nil -> + {line, column} = Metadata.position(end_metadata) + + if has_parens? do + {line, column + 1} + else + name_length = function_name |> Atom.to_string() |> String.length() + # without parens, the metadata points to the beginning of the call, so + # we need to add the length of the function name to be sure we have it + # all + {line, column + name_length} + end + end + + end_position = Position.new(document, end_line, end_column) + Range.new(start_position, end_position) + end + + defp start_position(metadata) do + Metadata.position(metadata) + end + + defp call_arity(args, metadata) when is_list(args) do + length(args) + pipeline_arity(metadata) + end + + defp call_arity(arity, metadata) when is_integer(arity) do + arity + pipeline_arity(metadata) + end + + defp call_arity(_, metadata), do: pipeline_arity(metadata) + + defp pipeline_arity(metadata) do + if Keyword.get(metadata, :pipeline?, false) do + 1 + else + 0 + end + end + + defp excluded_functions do + case :persistent_term.get(@excluded_functions_key, :not_found) do + :not_found -> + excluded_functions = build_excluded_functions() + :persistent_term.put(@excluded_functions_key, excluded_functions) + excluded_functions + + excluded_functions -> + excluded_functions + end + end + + defp build_excluded_functions do + excluded_kernel_macros = + for {macro_name, _arity} <- Kernel.__info__(:macros), + string_name = Atom.to_string(macro_name), + String.starts_with?(string_name, "def") do + macro_name + end + + # syntax specific functions to exclude from our matches + excluded_operators = + ~w[<- -> && ** ++ -- .. "..//" ! <> =~ @ |> | || * + - / != !== < <= == === > >=]a + + excluded_keywords = ~w[and if import in not or raise require try use]a + + excluded_special_forms = + :macros + |> Kernel.SpecialForms.__info__() + |> Keyword.keys() + + excluded_kernel_macros + |> Enum.concat(excluded_operators) + |> Enum.concat(excluded_special_forms) + |> Enum.concat(excluded_keywords) + end +end diff --git a/engine/lib/engine/search/indexer/extractors/module.ex b/engine/lib/engine/search/indexer/extractors/module.ex new file mode 100644 index 00000000..e010c3c3 --- /dev/null +++ b/engine/lib/engine/search/indexer/extractors/module.ex @@ -0,0 +1,344 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Extractors.Module do + @moduledoc """ + Extracts module references and definitions from AST + """ + + alias Lexical.Ast + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.ProcessCache + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Indexer.Metadata + alias Lexical.RemoteControl.Search.Indexer.Source.Block + alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + alias Lexical.RemoteControl.Search.Subject + + require Logger + + @definition_mappings %{ + defmodule: :module, + defprotocol: {:protocol, :definition} + } + @module_definitions Map.keys(@definition_mappings) + + # extract a module definition + def extract( + {definition, defmodule_meta, + [{:__aliases__, module_name_meta, module_name}, module_block]} = defmodule_ast, + %Reducer{} = reducer + ) + when definition in @module_definitions do + %Block{} = block = Reducer.current_block(reducer) + + case resolve_alias(reducer, module_name) do + {:ok, aliased_module} -> + module_position = Metadata.position(module_name_meta) + detail_range = to_range(reducer, module_name, module_position) + + entry = + Entry.block_definition( + reducer.analysis.document.path, + block, + Subject.module(aliased_module), + @definition_mappings[definition], + block_range(reducer.analysis.document, defmodule_ast), + detail_range, + Application.get_application(aliased_module) + ) + + module_name_meta = Reducer.skip(module_name_meta) + + elem = + {:defmodule, defmodule_meta, + [{:__aliases__, module_name_meta, module_name}, module_block]} + + {:ok, entry, elem} + + _ -> + :ignored + end + end + + # defimpl MyProtocol, for: MyStruct do ... + def extract( + {:defimpl, _, [{:__aliases__, _, module_name}, [for_block], _impl_body]} = defimpl_ast, + %Reducer{} = reducer + ) do + %Block{} = block = Reducer.current_block(reducer) + + with {:ok, protocol_module} <- resolve_alias(reducer, module_name), + {:ok, for_target} <- resolve_for_block(reducer, for_block) do + detail_range = defimpl_range(reducer, defimpl_ast) + implemented_module = Module.concat(protocol_module, for_target) + + implementation_entry = + Entry.block_definition( + reducer.analysis.document.path, + block, + Subject.module(protocol_module), + {:protocol, :implementation}, + block_range(reducer.analysis.document, defimpl_ast), + detail_range, + Application.get_application(protocol_module) + ) + + module_entry = + Entry.copy(implementation_entry, + subject: Subject.module(implemented_module), + type: :module + ) + + {:ok, [implementation_entry, module_entry]} + else + _ -> + :ignored + end + end + + # This matches an elixir module reference + def extract({:__aliases__, metadata, maybe_module}, %Reducer{} = reducer) + when is_list(maybe_module) do + case module(reducer, maybe_module) do + {:ok, module} -> + start = Metadata.position(metadata) + range = to_range(reducer, maybe_module, start) + %Block{} = current_block = Reducer.current_block(reducer) + + entry = + Entry.reference( + reducer.analysis.document.path, + current_block, + Subject.module(module), + :module, + range, + Application.get_application(module) + ) + + {:ok, entry, nil} + + _ -> + :ignored + end + end + + @module_length String.length("__MODULE__") + # This matches __MODULE__ references + def extract({:__MODULE__, metadata, _} = ast, %Reducer{} = reducer) do + line = Sourceror.get_line(ast) + pos = Position.new(reducer.analysis.document, line - 1, 1) + + case RemoteControl.Analyzer.current_module(reducer.analysis, pos) do + {:ok, current_module} -> + {start_line, start_col} = Metadata.position(metadata) + start_pos = Position.new(reducer.analysis.document, start_line, start_col) + + end_pos = + Position.new( + reducer.analysis.document, + start_line, + start_col + @module_length + ) + + range = Range.new(start_pos, end_pos) + %Block{} = current_block = Reducer.current_block(reducer) + + entry = + Entry.reference( + reducer.analysis.document.path, + current_block, + Subject.module(current_module), + :module, + range, + Application.get_application(current_module) + ) + + {:ok, entry} + + _ -> + :ignored + end + end + + # This matches an erlang module, which is just an atom + def extract({:__block__, metadata, [atom_literal]}, %Reducer{} = reducer) + when is_atom(atom_literal) do + case module(reducer, atom_literal) do + {:ok, module} -> + start = Metadata.position(metadata) + %Block{} = current_block = Reducer.current_block(reducer) + range = to_range(reducer, module, start) + + entry = + Entry.reference( + reducer.analysis.document.path, + current_block, + Subject.module(module), + :module, + range, + Application.get_application(module) + ) + + {:ok, entry} + + :error -> + :ignored + end + end + + # Function capture with arity: &OtherModule.foo/3 + def extract( + {:&, _, + [ + {:/, _, + [ + {{:., _, [{:__aliases__, start_metadata, maybe_module}, _function_name]}, _, []}, + _ + ]} + ]}, + %Reducer{} = reducer + ) do + case module(reducer, maybe_module) do + {:ok, module} -> + start = Metadata.position(start_metadata) + range = to_range(reducer, maybe_module, start) + %Block{} = current_block = Reducer.current_block(reducer) + + entry = + Entry.reference( + reducer.analysis.document.path, + current_block, + Subject.module(module), + :module, + range, + Application.get_application(module) + ) + + {:ok, entry} + + _ -> + :ignored + end + end + + def extract(_, _) do + :ignored + end + + defp defimpl_range(%Reducer{} = reducer, {_, protocol_meta, _} = protocol_ast) do + start = Sourceror.get_start_position(protocol_ast) + {finish_line, finish_column} = Metadata.position(protocol_meta, :do) + # add two to include the do + finish_column = finish_column + 2 + document = reducer.analysis.document + + Range.new( + Position.new(document, start[:line], start[:column]), + Position.new(document, finish_line, finish_column) + ) + end + + defp resolve_for_block( + %Reducer{} = reducer, + {{:__block__, _, [:for]}, {:__aliases__, _, for_target}} + ) do + resolve_alias(reducer, for_target) + end + + defp resolve_for_block(_, _), do: :error + + defp resolve_alias(%Reducer{} = reducer, unresolved_alias) do + position = Reducer.position(reducer) + + RemoteControl.Analyzer.expand_alias(unresolved_alias, reducer.analysis, position) + end + + defp module(%Reducer{} = reducer, maybe_module) when is_list(maybe_module) do + with true <- Enum.all?(maybe_module, &module_part?/1), + {:ok, resolved} <- resolve_alias(reducer, maybe_module) do + {:ok, resolved} + else + _ -> + human_location = Reducer.human_location(reducer) + + Logger.warning( + "Could not expand module #{inspect(maybe_module)}. Please report this (at #{human_location})" + ) + + :error + end + end + + defp module(%Reducer{}, maybe_erlang_module) when is_atom(maybe_erlang_module) do + if available_module?(maybe_erlang_module) do + {:ok, maybe_erlang_module} + else + :error + end + end + + defp module(_, _), do: :error + + @protocol_module_attribue_names [:protocol, :for] + + @starts_with_capital ~r/[A-Z]+/ + defp module_part?(part) when is_atom(part) do + Regex.match?(@starts_with_capital, Atom.to_string(part)) + end + + defp module_part?({:@, _, [{type, _, _} | _]}) when type in @protocol_module_attribue_names, + do: true + + defp module_part?({:__MODULE__, _, context}) when is_atom(context), do: true + + defp module_part?(_), do: false + + defp available_module?(potential_module) do + MapSet.member?(all_modules(), potential_module) + end + + defp all_modules do + ProcessCache.trans(:all_modules, fn -> + MapSet.new(:code.all_available(), fn {module_charlist, _, _} -> + List.to_atom(module_charlist) + end) + end) + end + + # handles @protocol and @for in defimpl blocks + defp to_range(%Reducer{} = reducer, [{:@, _, [{type, _, _} | _]} = attribute | segments], _) + when type in @protocol_module_attribue_names do + range = Sourceror.get_range(attribute) + + document = reducer.analysis.document + module_length = segments |> Ast.Module.name() |> String.length() + # add one because we're off by the @ sign + end_column = range.end[:column] + module_length + 1 + + Range.new( + Position.new(document, range.start[:line], range.start[:column]), + Position.new(document, range.end[:line], end_column) + ) + end + + defp to_range(%Reducer{} = reducer, module_name, {line, column}) do + document = reducer.analysis.document + + module_length = + module_name + |> Ast.Module.name() + |> String.length() + + Range.new( + Position.new(document, line, column), + Position.new(document, line, column + module_length) + ) + end + + defp block_range(document, ast) do + case Ast.Range.fetch(ast, document) do + {:ok, range} -> range + _ -> nil + end + end +end diff --git a/engine/lib/engine/search/indexer/extractors/module_attribute.ex b/engine/lib/engine/search/indexer/extractors/module_attribute.ex new file mode 100644 index 00000000..f182e832 --- /dev/null +++ b/engine/lib/engine/search/indexer/extractors/module_attribute.ex @@ -0,0 +1,107 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Extractors.ModuleAttribute do + @moduledoc """ + Extracts module attribute definitions and references from AST + """ + + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.RemoteControl.Analyzer + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + alias Lexical.RemoteControl.Search.Subject + + require Logger + + # Finds module attribute usages + def extract({:@, _, [{attr_name, _, nil}]}, %Reducer{} = reducer) do + block = Reducer.current_block(reducer) + + case Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) do + {:ok, current_module} -> + reference = + Entry.reference( + reducer.analysis.document.path, + block, + Subject.module_attribute(current_module, attr_name), + :module_attribute, + reference_range(reducer, attr_name), + Application.get_application(current_module) + ) + + {:ok, reference} + + :error -> + :ignored + end + end + + # an attribute being typed above an already existing attribute will have the name `@`, which we ignore + # example: + # @| + # @callback foo() :: :ok + def extract({:@, _, [{:@, _, _attr_value}]}, %Reducer{}) do + :ignored + end + + # Finds module attribute definitions @foo 3 + def extract({:@, _, [{attr_name, _, _attr_value}]} = attr, %Reducer{} = reducer) do + block = Reducer.current_block(reducer) + + case Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) do + {:ok, current_module} -> + definition = + Entry.definition( + reducer.analysis.document.path, + block, + Subject.module_attribute(current_module, attr_name), + :module_attribute, + definition_range(reducer, attr), + Application.get_application(current_module) + ) + + {:ok, definition} + + _ -> + :ignored + end + end + + def extract(_, _) do + :ignored + end + + defp reference_range(%Reducer{} = reducer, attr_name) do + document = reducer.analysis.document + + name_length = + attr_name + |> Atom.to_string() + |> String.length() + + {start_line, start_column} = reducer.position + + # add 1 to include the @ character + end_column = start_column + name_length + 1 + + Range.new( + Position.new(document, start_line, start_column), + Position.new(document, start_line, end_column) + ) + end + + defp definition_range(%Reducer{} = reducer, attr_ast) do + document = reducer.analysis.document + + [line: start_line, column: start_column] = Sourceror.get_start_position(attr_ast) + + end_line = Sourceror.get_end_line(attr_ast) + {:ok, line_text} = Lexical.Document.fetch_text_at(document, end_line) + # add one because lsp positions are one-based + end_column = String.length(line_text) + 1 + + Range.new( + Position.new(document, start_line, start_column), + Position.new(document, end_line, end_column) + ) + end +end diff --git a/engine/lib/engine/search/indexer/extractors/struct_definition.ex b/engine/lib/engine/search/indexer/extractors/struct_definition.ex new file mode 100644 index 00000000..b8663a30 --- /dev/null +++ b/engine/lib/engine/search/indexer/extractors/struct_definition.ex @@ -0,0 +1,35 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Extractors.StructDefinition do + alias Lexical.Ast + alias Lexical.RemoteControl.Analyzer + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + + def extract({:defstruct, _, [_fields]} = definition, %Reducer{} = reducer) do + document = reducer.analysis.document + block = Reducer.current_block(reducer) + + case Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) do + {:ok, current_module} -> + range = Ast.Range.fetch!(definition, document) + + entry = + Entry.definition( + document.path, + block, + current_module, + :struct, + range, + Application.get_application(current_module) + ) + + {:ok, entry} + + _ -> + :ignored + end + end + + def extract(_, _) do + :ignored + end +end diff --git a/engine/lib/engine/search/indexer/extractors/struct_reference.ex b/engine/lib/engine/search/indexer/extractors/struct_reference.ex new file mode 100644 index 00000000..46b77018 --- /dev/null +++ b/engine/lib/engine/search/indexer/extractors/struct_reference.ex @@ -0,0 +1,93 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Extractors.StructReference do + alias Lexical.Ast + alias Lexical.RemoteControl.Analyzer + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + alias Lexical.RemoteControl.Search.Subject + + require Logger + + @struct_fn_names [:struct, :struct!] + + # Handles usages via an alias, e.g. x = %MyStruct{...} or %__MODULE__{...} + def extract( + {:%, _, [struct_alias, {:%{}, _, _struct_args}]} = reference, + %Reducer{} = reducer + ) do + case expand_alias(struct_alias, reducer) do + {:ok, struct_module} -> + {:ok, entry(reducer, struct_module, reference)} + + _ -> + :ignored + end + end + + # Call to Kernel.struct with a fully qualified module e.g. Kernel.struct(MyStruct, ...) + def extract( + {{:., _, [kernel_alias, struct_fn_name]}, _, [struct_alias | _]} = reference, + %Reducer{} = reducer + ) + when struct_fn_name in @struct_fn_names do + with {:ok, Kernel} <- expand_alias(kernel_alias, reducer), + {:ok, struct_module} <- expand_alias(struct_alias, reducer) do + {:ok, entry(reducer, struct_module, reference)} + else + _ -> + :ignored + end + end + + # handles calls to Kernel.struct e.g. struct(MyModule) or struct(MyModule, foo: 3) + def extract({struct_fn_name, _, [struct_alias | _] = args} = reference, %Reducer{} = reducer) + when struct_fn_name in @struct_fn_names do + reducer_position = Reducer.position(reducer) + imports = Analyzer.imports_at(reducer.analysis, reducer_position) + arity = length(args) + + with true <- Enum.member?(imports, {Kernel, struct_fn_name, arity}), + {:ok, struct_module} <- expand_alias(struct_alias, reducer) do + {:ok, entry(reducer, struct_module, reference)} + else + _ -> + :ignored + end + end + + def extract(_, _) do + :ignored + end + + defp entry(%Reducer{} = reducer, struct_module, reference) do + document = reducer.analysis.document + block = Reducer.current_block(reducer) + subject = Subject.module(struct_module) + + Entry.reference( + document.path, + block, + subject, + :struct, + Ast.Range.fetch!(reference, document), + Application.get_application(struct_module) + ) + end + + defp expand_alias({:__aliases__, _, struct_alias}, %Reducer{} = reducer) do + Analyzer.expand_alias(struct_alias, reducer.analysis, Reducer.position(reducer)) + end + + defp expand_alias({:__MODULE__, _, _}, %Reducer{} = reducer) do + Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) + end + + defp expand_alias(alias, %Reducer{} = reducer) do + {line, column} = reducer.position + + Logger.error( + "Could not expand alias: #{inspect(alias)} at #{reducer.analysis.document.path} #{line}:#{column}" + ) + + :error + end +end diff --git a/engine/lib/engine/search/indexer/extractors/variable.ex b/engine/lib/engine/search/indexer/extractors/variable.ex new file mode 100644 index 00000000..bd433aee --- /dev/null +++ b/engine/lib/engine/search/indexer/extractors/variable.ex @@ -0,0 +1,249 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Extractors.Variable do + alias Lexical.Ast + alias Lexical.RemoteControl.Analyzer + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + + @defs [:def, :defmacro, :defp, :defmacrop] + + def extract( + {def, _, [{:when, _, [{_fn_name, _, params} | when_args]}, body]}, + %Reducer{} = reducer + ) + when def in @defs do + entries = extract_definitions(params, reducer) ++ extract_references(when_args, reducer) + {:ok, entries, body} + end + + def extract({def, _, [{_fn_name, _, params}, body]}, %Reducer{} = reducer) + when def in @defs do + entries = extract_definitions(params, reducer) + + {:ok, entries, body} + end + + # Stab operator x -> body + def extract({:->, _, [params, body]}, %Reducer{} = reducer) do + entries = extract_definitions(params, reducer) ++ extract_in_definitions(params, reducer) + + {:ok, entries, List.wrap(body)} + end + + # with match operator. with {:ok, var} <- something() + def extract({:<-, _, [left, right]}, %Reducer{} = reducer) do + entries = extract_definitions(left, reducer) + + {:ok, entries, List.wrap(right)} + end + + # Match operator left = right + def extract({:=, _, [left, right]}, %Reducer{} = reducer) do + definitions = extract_definitions(left, reducer) + + {:ok, definitions, List.wrap(right)} + end + + # String interpolations "#{foo}" + def extract( + {:<<>>, _, [{:"::", _, [{{:., _, [Kernel, :to_string]}, _, body}, {:binary, _, _}]}]}, + %Reducer{} + ) do + {:ok, [], body} + end + + # Test declarations + def extract( + {:test, _metadata, + [ + {:__block__, [delimiter: "\"", line: 3, column: 8], ["my test"]}, + args, + body + ]}, + %Reducer{} = reducer + ) do + entries = extract_definitions(args, reducer) + {:ok, entries, body} + end + + def extract({:binary, _, _}, %Reducer{}) do + :ignored + end + + def extract({:@, _, _}, %Reducer{}) do + {:ok, nil, nil} + end + + # Generic variable reference + def extract({var_name, _, _} = ast, %Reducer{} = reducer) when is_atom(var_name) do + case extract_reference(ast, reducer, get_current_app(reducer)) do + %Entry{} = entry -> {:ok, entry} + _ -> :ignored + end + end + + # Pin operator ^pinned_variable + def extract({:^, _, [reference]}, %Reducer{} = reducer) do + reference = extract_reference(reference, reducer, get_current_app(reducer)) + + {:ok, reference, nil} + end + + def extract(_ast, _reducer) do + :ignored + end + + defp extract_definitions(ast, reducer) do + current_app = get_current_app(reducer) + + {_ast, entries} = + Macro.prewalk(ast, [], fn ast, acc -> + case extract_definition(ast, reducer, current_app) do + %Entry{} = entry -> + {ast, [entry | acc]} + + {%Entry{} = entry, ast} -> + {ast, [entry | acc]} + + {entries, ast} when is_list(entries) -> + {ast, entries ++ acc} + + {_, ast} -> + {ast, acc} + + _ -> + {ast, acc} + end + end) + + Enum.reverse(entries) + end + + # the pin operator is always on the left side of a pattern match, but it's + # not defining a variable, just referencing one. + defp extract_definition({:^, _, [reference]}, %Reducer{} = reducer, current_app) do + reference = extract_reference(reference, reducer, current_app) + + {reference, nil} + end + + # unquote(expression) + defp extract_definition({:unquote, _, [expr]}, %Reducer{} = reducer, current_app) do + reference = extract_reference(expr, reducer, current_app) + {reference, nil} + end + + defp extract_definition({:@, _, _}, %Reducer{}, _current_app) do + {nil, []} + end + + # when clauses actually contain parameters and references + defp extract_definition({:when, _, when_args}, %Reducer{} = reducer, _current_app) do + {definitions, references} = + Enum.split_with(when_args, fn {_, _, context} -> is_atom(context) end) + + definitions = extract_definitions(definitions, reducer) + references = extract_references(references, reducer) + + {Enum.reverse(definitions ++ references), nil} + end + + # This is an effect of string interpolation + defp extract_definition({:binary, _metadata, nil}, _reducer, _current_app) do + nil + end + + defp extract_definition({var_name, _metadata, nil} = ast, reducer, current_app) do + if used_variable?(var_name) do + document = reducer.analysis.document + block = Reducer.current_block(reducer) + + Entry.definition( + document.path, + block, + var_name, + :variable, + Ast.Range.fetch!(ast, document), + current_app + ) + end + end + + defp extract_definition(_, _reducer, _current_app), do: nil + + defp extract_references(ast, reducer) do + current_app = get_current_app(reducer) + + {_ast, entries} = + Macro.prewalk(ast, [], fn ast, acc -> + case extract_reference(ast, reducer, current_app) do + %Entry{} = entry -> + {ast, [entry | acc]} + + _ -> + {ast, acc} + end + end) + + Enum.reverse(entries) + end + + defp extract_reference({var_name, _metadata, nil} = ast, reducer, current_app) do + if used_variable?(var_name) do + document = reducer.analysis.document + block = Reducer.current_block(reducer) + + Entry.reference( + document.path, + block, + var_name, + :variable, + Ast.Range.fetch!(ast, document), + current_app + ) + end + end + + defp extract_reference(_, _, _) do + nil + end + + # extracts definitions like e in SomeException -> + defp extract_in_definitions(ast, %Reducer{} = reducer) do + current_app = get_current_app(reducer) + + {_ast, entries} = + Macro.prewalk(ast, [], fn ast, acc -> + case extract_in_definition(ast, reducer, current_app) do + %Entry{} = entry -> + {ast, [entry | acc]} + + _ -> + {ast, acc} + end + end) + + Enum.reverse(entries) + end + + defp extract_in_definition( + [[{:in, _, [definition, _right]}], _body], + %Reducer{} = reducer, + current_app + ) do + extract_definition(definition, reducer, current_app) + end + + defp extract_in_definition(_ast, %Reducer{}, _current_app), do: nil + + defp get_current_app(%Reducer{} = reducer) do + with {:ok, module} <- Analyzer.current_module(reducer.analysis, Reducer.position(reducer)) do + Application.get_application(module) + end + end + + defp used_variable?(variable_name) do + not (variable_name + |> Atom.to_string() + |> String.starts_with?("_")) + end +end diff --git a/engine/lib/engine/search/indexer/metadata.ex b/engine/lib/engine/search/indexer/metadata.ex new file mode 100644 index 00000000..e8453219 --- /dev/null +++ b/engine/lib/engine/search/indexer/metadata.ex @@ -0,0 +1,74 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Metadata do + @moduledoc """ + Utilities for extracting location information from AST metadata nodes. + """ + def location({_, metadata, _} = ast) do + if Keyword.has_key?(metadata, :do) do + position = position(metadata) + block_start = position(metadata, :do) + block_end = position(metadata, :end_of_expression) || position(metadata, :end) + {:block, position, block_start, block_end} + else + maybe_handle_terse_function(ast) + end + end + + def location(_unknown) do + {:expression, nil} + end + + def position(keyword) do + line = Keyword.get(keyword, :line) + column = Keyword.get(keyword, :column) + + case {line, column} do + {nil, nil} -> + nil + + position -> + position + end + end + + def position(keyword, key) do + keyword + |> Keyword.get(key, []) + |> position() + end + + @defines [:def, :defp, :defmacro, :defmacrop, :fn] + # a terse function is one without a do/end block + defp maybe_handle_terse_function({define, metadata, [_name_and_args | [[block | _]]]}) + when define in @defines do + block_location(block, metadata) + end + + defp maybe_handle_terse_function({:fn, metadata, _} = ast) do + block_location(ast, metadata) + end + + defp maybe_handle_terse_function({_, metadata, _}) do + {:expression, position(metadata)} + end + + defp block_location(block, metadata) do + case Sourceror.get_range(block) do + %{start: start_pos, end: end_pos} -> + position = position(metadata) + {:block, position, keyword_to_position(start_pos), keyword_to_position(end_pos)} + + _ -> + {:expression, position(metadata)} + end + end + + defp keyword_to_position(keyword) do + case Keyword.take(keyword, [:line, :column]) do + [line: line, column: column] when is_number(line) and is_number(column) -> + {line, column} + + _ -> + nil + end + end +end diff --git a/engine/lib/engine/search/indexer/module.ex b/engine/lib/engine/search/indexer/module.ex new file mode 100644 index 00000000..55632bf9 --- /dev/null +++ b/engine/lib/engine/search/indexer/module.ex @@ -0,0 +1,27 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Module do + alias Lexical.RemoteControl.Search.Indexer + + def index(module) do + with true <- indexable?(module), + {:ok, path, source} <- source_file_path(module) do + Indexer.Source.index(path, source) + else + _ -> + nil + end + end + + defp source_file_path(module) do + with {:ok, file_path} <- Keyword.fetch(module.__info__(:compile), :source), + {:ok, contents} <- File.read(file_path) do + {:ok, file_path, contents} + end + end + + defp indexable?(Kernel.SpecialForms), do: false + + defp indexable?(module) do + module_string = to_string(module) + String.starts_with?(module_string, "Elixir.") + end +end diff --git a/engine/lib/engine/search/indexer/quoted.ex b/engine/lib/engine/search/indexer/quoted.ex new file mode 100644 index 00000000..18cac388 --- /dev/null +++ b/engine/lib/engine/search/indexer/quoted.ex @@ -0,0 +1,29 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Quoted do + alias Lexical.Ast.Analysis + alias Lexical.ProcessCache + alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + + require ProcessCache + + def index_with_cleanup(%Analysis{} = analysis) do + ProcessCache.with_cleanup do + index(analysis) + end + end + + def index(analysis, extractors \\ nil) + + def index(%Analysis{valid?: true} = analysis, extractors) do + {_, reducer} = + Macro.prewalk(analysis.ast, Reducer.new(analysis, extractors), fn elem, reducer -> + {reducer, elem} = Reducer.reduce(reducer, elem) + {elem, reducer} + end) + + {:ok, Reducer.entries(reducer)} + end + + def index(%Analysis{valid?: false}, _extractors) do + {:ok, []} + end +end diff --git a/engine/lib/engine/search/indexer/source.ex b/engine/lib/engine/search/indexer/source.ex new file mode 100644 index 00000000..cd21c009 --- /dev/null +++ b/engine/lib/engine/search/indexer/source.ex @@ -0,0 +1,19 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Source do + alias Lexical.Ast + alias Lexical.Document + alias Lexical.RemoteControl.Search.Indexer + + require Logger + + def index(path, source, extractors \\ nil) do + path + |> Document.new(source, 1) + |> index_document(extractors) + end + + def index_document(%Document{} = document, extractors \\ nil) do + document + |> Ast.analyze() + |> Indexer.Quoted.index(extractors) + end +end diff --git a/engine/lib/engine/search/indexer/source/block.ex b/engine/lib/engine/search/indexer/source/block.ex new file mode 100644 index 00000000..7cc5cd56 --- /dev/null +++ b/engine/lib/engine/search/indexer/source/block.ex @@ -0,0 +1,17 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Source.Block do + @moduledoc """ + A struct that represents a block of source code + """ + + defstruct [:starts_at, :ends_at, :id, :parent_id] + alias Lexical.Identifier + + def root do + %__MODULE__{id: :root} + end + + def new(starts_at, ends_at) do + id = Identifier.next_global!() + %__MODULE__{starts_at: starts_at, ends_at: ends_at, id: id} + end +end diff --git a/engine/lib/engine/search/indexer/source/reducer.ex b/engine/lib/engine/search/indexer/source/reducer.ex new file mode 100644 index 00000000..9880f030 --- /dev/null +++ b/engine/lib/engine/search/indexer/source/reducer.ex @@ -0,0 +1,187 @@ +defmodule Lexical.RemoteControl.Search.Indexer.Source.Reducer do + @moduledoc """ + A module and struct that can reduce over elixir AST via Macro.prewalk/3 + + The reducer keeps track of blocks and parent / child relationships so extractors don't have to concern themselves + with the AST's overall structure, and can focus on extracting content from it. + """ + + alias Lexical.Ast.Analysis + alias Lexical.Document.Position + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Indexer.Extractors + alias Lexical.RemoteControl.Search.Indexer.Metadata + alias Lexical.RemoteControl.Search.Indexer.Source.Block + + defstruct [:analysis, :entries, :position, :blocks, :block_hierarchy, extractors: []] + + @extractors [ + Extractors.Module, + Extractors.ModuleAttribute, + Extractors.FunctionDefinition, + Extractors.FunctionReference, + Extractors.StructDefinition, + Extractors.StructReference, + Extractors.EctoSchema + ] + + def new(%Analysis{} = analysis, extractors \\ nil) do + %__MODULE__{ + analysis: analysis, + block_hierarchy: %{root: %{}}, + blocks: [Block.root()], + entries: [], + extractors: extractors || @extractors, + position: {0, 0} + } + end + + def human_location(%__MODULE__{} = reducer) do + {line, column} = reducer.position + path = reducer.analysis.document.path + "#{path} #{line}:#{column}" + end + + def entries(%__MODULE__{} = reducer) do + [hierarchy(reducer) | Enum.reverse(reducer.entries)] + end + + def skip(meta) do + Keyword.put(meta, :__skipped__, true) + end + + def skip?({_, meta, _}) do + Keyword.get(meta, :__skipped__, false) + end + + def skip?(_), do: false + + def reduce(%__MODULE__{} = reducer, element) do + if skip?(element) do + {reducer, element} + else + do_reduce(reducer, element) + end + end + + def position(%__MODULE__{} = reducer) do + {line, column} = reducer.position + Position.new(reducer.analysis.document, line, column) + end + + defp hierarchy(%__MODULE__{} = reducer) do + Entry.block_structure(reducer.analysis.document.path, reducer.block_hierarchy) + end + + defp do_reduce(%__MODULE__{} = reducer, element) do + case Metadata.location(element) do + {:block, position, block_start, block_end} -> + block = Block.new(block_start, block_end) + + reducer + |> update_position(position) + |> maybe_pop_block() + |> push_block(block) + |> apply_extractors(element) + + {:expression, position} -> + reducer + |> update_position(position) + |> maybe_pop_block() + |> apply_extractors(element) + end + end + + defp apply_extractors(%__MODULE__{} = reducer, element) do + Enum.reduce(reducer.extractors, {reducer, element}, fn detector_module, {reducer, element} -> + case detector_module.extract(element, reducer) do + {:ok, entry} -> + reducer = push_entry(reducer, entry) + {reducer, element} + + {:ok, entry, elem} -> + reducer = push_entry(reducer, entry) + + {reducer, elem} + + :ignored -> + {reducer, element} + end + end) + end + + defp update_position(%__MODULE__{} = reducer, nil) do + reducer + end + + defp update_position(%__MODULE__{} = reducer, position) do + Map.put(reducer, :position, position) + end + + def current_block(%__MODULE__{} = reducer) do + List.first(reducer.blocks) + end + + defp push_block(%__MODULE__{} = reducer, %Block{} = block) do + parent = current_block(reducer) + block = %Block{block | parent_id: parent.id} + id_path = Enum.reduce(reducer.blocks, [], fn block, acc -> [block.id | acc] end) + + hierarchy = + update_in(reducer.block_hierarchy, id_path, fn current -> + Map.put(current, block.id, %{}) + end) + + %__MODULE__{reducer | blocks: [block | reducer.blocks], block_hierarchy: hierarchy} + end + + # you never pop the root block in a document + defp pop_block(%__MODULE__{blocks: [%Block{id: :root}]} = reducer), do: reducer + + defp pop_block(%__MODULE__{} = reducer) do + [_ | rest] = reducer.blocks + %__MODULE__{reducer | blocks: rest} + end + + # The root block in the document goes on forever + defp block_ended?(%__MODULE__{blocks: [%Block{id: :root}]}), do: false + + defp block_ended?(%__MODULE__{} = reducer) do + %Block{} = block = current_block(reducer) + + {ends_at_line, ends_at_column} = block.ends_at + + {current_line, current_column} = reducer.position + + cond do + current_line == ends_at_line and current_column > ends_at_column -> + true + + current_line > ends_at_line -> + true + + true -> + false + end + end + + defp push_entry(%__MODULE__{} = reducer, entries) when is_list(entries) do + Enum.reduce(entries, reducer, &push_entry(&2, &1)) + end + + defp push_entry(%__MODULE__{} = reducer, %Entry{} = entry) do + %__MODULE__{reducer | entries: [entry | reducer.entries]} + end + + defp push_entry(%__MODULE__{} = reducer, _), do: reducer + + defp maybe_pop_block(%__MODULE__{} = reducer) do + if block_ended?(reducer) do + reducer + |> pop_block() + |> maybe_pop_block() + else + reducer + end + end +end diff --git a/engine/lib/engine/search/store.ex b/engine/lib/engine/search/store.ex new file mode 100644 index 00000000..0ad31fb2 --- /dev/null +++ b/engine/lib/engine/search/store.ex @@ -0,0 +1,294 @@ +defmodule Lexical.RemoteControl.Search.Store do + @moduledoc """ + A persistent store for search entries + """ + + alias Lexical.Project + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Api + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Store + alias Lexical.RemoteControl.Search.Store.State + + @type index_state :: :empty | :stale + @type existing_entries :: [Entry.t()] + @type new_entries :: [Entry.t()] + @type updated_entries :: [Entry.t()] + @type paths_to_delete :: [Path.t()] + @typedoc """ + A function that creates indexes when none is detected + """ + @type create_index :: + (project :: Project.t() -> + {:ok, new_entries} | {:error, term()}) + + @typedoc """ + A function that takes existing entries and refreshes them if necessary + """ + @type refresh_index :: + (project :: Project.t(), entries :: existing_entries -> + {:ok, new_entries, paths_to_delete} | {:error, term()}) + + @backend Application.compile_env(:remote_control, :search_store_backend, Store.Backends.Ets) + @flush_interval_ms Application.compile_env( + :remote_control, + :search_store_quiescent_period_ms, + 2500 + ) + + import Api.Messages + use GenServer + require Logger + + def stop do + GenServer.stop(__MODULE__) + end + + def loaded? do + GenServer.call(__MODULE__, :loaded?) + end + + def replace(entries) do + GenServer.call(__MODULE__, {:replace, entries}) + end + + @spec exact(Entry.subject_query(), Entry.constraints()) :: {:ok, [Entry.t()]} | {:error, term()} + def exact(subject \\ :_, constraints) do + call_or_default({:exact, subject, constraints}, []) + end + + @spec prefix(String.t(), Entry.constraints()) :: {:ok, [Entry.t()]} | {:error, term()} + def prefix(prefix, constraints) do + call_or_default({:prefix, prefix, constraints}, []) + end + + @spec parent(Entry.t()) :: {:ok, Entry.t()} | {:error, term()} + def parent(%Entry{} = entry) do + call_or_default({:parent, entry}, nil) + end + + @spec siblings(Entry.t()) :: {:ok, [Entry.t()]} | {:error, term()} + def siblings(%Entry{} = entry) do + call_or_default({:siblings, entry}, []) + end + + @spec fuzzy(Entry.subject(), Entry.constraints()) :: {:ok, [Entry.t()]} | {:error, term()} + def fuzzy(subject, constraints) do + call_or_default({:fuzzy, subject, constraints}, []) + end + + def clear(path) do + GenServer.call(__MODULE__, {:update, path, []}) + end + + def update(path, entries) do + GenServer.call(__MODULE__, {:update, path, entries}) + end + + def destroy do + GenServer.call(__MODULE__, :destroy) + end + + def enable do + GenServer.call(__MODULE__, :enable) + end + + @spec start_link(Project.t(), create_index, refresh_index, module()) :: GenServer.on_start() + def start_link(%Project{} = project, create_index, refresh_index, backend) do + GenServer.start_link(__MODULE__, [project, create_index, refresh_index, backend], + name: __MODULE__ + ) + end + + def child_spec(init_args) when is_list(init_args) do + %{ + id: __MODULE__, + start: {__MODULE__, :start_link, normalize_init_args(init_args)} + } + end + + defp normalize_init_args([create_index, refresh_index]) do + normalize_init_args([Lexical.RemoteControl.get_project(), create_index, refresh_index]) + end + + defp normalize_init_args([%Project{} = project, create_index, refresh_index]) do + normalize_init_args([project, create_index, refresh_index, backend()]) + end + + defp normalize_init_args([%Project{}, create_index, refresh_index, backend] = args) + when is_function(create_index, 1) and is_function(refresh_index, 2) and is_atom(backend) do + args + end + + @impl GenServer + def init([%Project{} = project, create_index, update_index, backend]) do + Process.flag(:fullsweep_after, 5) + schedule_gc() + # I've found that if indexing happens before the first compile, for some reason + # the compilation is 4x slower than if indexing happens after it. I was + # unable to figure out why this is the case, and I looked extensively, so instead + # we have this bandaid. We wait for the first compilation to complete, and then + # the search store enables itself, at which point we index the code. + + RemoteControl.register_listener(self(), project_compiled()) + state = State.new(project, create_index, update_index, backend) + {:ok, state} + end + + @impl GenServer + # enable ourselves when the project is force compiled + def handle_info(project_compiled(), %State{} = state) do + {:noreply, enable(state)} + end + + def handle_info(project_compiled(), {_, _} = state) do + # we're already enabled, no need to do anything + {:noreply, state} + end + + # handle the result from `State.async_load/1` + def handle_info({ref, result}, {update_ref, %State{async_load_ref: ref} = state}) do + {:noreply, {update_ref, State.async_load_complete(state, result)}} + end + + def handle_info(:flush_updates, {_, %State{} = state}) do + {:ok, state} = State.flush_buffered_updates(state) + ref = schedule_flush() + {:noreply, {ref, state}} + end + + def handle_info(:gc, state) do + :erlang.garbage_collect() + schedule_gc() + {:noreply, state} + end + + def handle_info(_, state) do + {:noreply, state} + end + + @impl GenServer + def handle_call(:enable, _from, %State{} = state) do + {:reply, :ok, enable(state)} + end + + def handle_call(:enable, _from, state) do + {:reply, :ok, state} + end + + def handle_call({:replace, entities}, _from, {ref, %State{} = state}) do + {reply, new_state} = + case State.replace(state, entities) do + {:ok, new_state} -> + {:ok, State.drop_buffered_updates(new_state)} + + {:error, _} = error -> + {error, state} + end + + {:reply, reply, {ref, new_state}} + end + + def handle_call({:exact, subject, constraints}, _from, {ref, %State{} = state}) do + {:reply, State.exact(state, subject, constraints), {ref, state}} + end + + def handle_call({:prefix, prefix, constraints}, _from, {ref, %State{} = state}) do + {:reply, State.prefix(state, prefix, constraints), {ref, state}} + end + + def handle_call({:fuzzy, subject, constraints}, _from, {ref, %State{} = state}) do + {:reply, State.fuzzy(state, subject, constraints), {ref, state}} + end + + def handle_call({:update, path, entries}, _from, {ref, %State{} = state}) do + {reply, new_ref, new_state} = do_update(state, ref, path, entries) + + {:reply, reply, {new_ref, new_state}} + end + + def handle_call({:parent, entry}, _from, {_, %State{} = state} = orig_state) do + parent = State.parent(state, entry) + {:reply, parent, orig_state} + end + + def handle_call({:siblings, entry}, _from, {_, %State{} = state} = orig_state) do + siblings = State.siblings(state, entry) + {:reply, siblings, orig_state} + end + + def handle_call(:on_stop, _, {ref, %State{} = state}) do + {:ok, state} = State.flush_buffered_updates(state) + + State.drop(state) + {:reply, :ok, {ref, state}} + end + + def handle_call(:loaded?, _, {ref, %State{loaded?: loaded?} = state}) do + {:reply, loaded?, {ref, state}} + end + + def handle_call(:loaded?, _, %State{loaded?: loaded?} = state) do + # We're not enabled yet, but we can still reply to the query + {:reply, loaded?, state} + end + + def handle_call(:destroy, _, {ref, %State{} = state}) do + new_state = State.destroy(state) + {:reply, :ok, {ref, new_state}} + end + + def handle_call(message, _from, %State{} = state) do + Logger.warning("Received #{inspect(message)}, but the search store isn't enabled yet.") + {:reply, {:error, {:not_enabled, message}}, state} + end + + @impl GenServer + def terminate(_reason, {_, state}) do + {:ok, state} = State.flush_buffered_updates(state) + {:noreply, state} + end + + defp backend do + @backend + end + + defp do_update(state, old_ref, path, entries) do + {:ok, schedule_flush(old_ref), State.buffer_updates(state, path, entries)} + end + + defp schedule_flush(ref) when is_reference(ref) do + Process.cancel_timer(ref) + schedule_flush() + end + + defp schedule_flush(_) do + schedule_flush() + end + + defp schedule_flush do + Process.send_after(self(), :flush_updates, @flush_interval_ms) + end + + defp enable(%State{} = state) do + state = State.async_load(state) + :persistent_term.put({__MODULE__, :enabled?}, true) + {nil, state} + end + + defp schedule_gc do + Process.send_after(self(), :gc, :timer.seconds(5)) + end + + defp call_or_default(call, default) do + if enabled?() do + GenServer.call(__MODULE__, call) + else + default + end + end + + defp enabled? do + :persistent_term.get({__MODULE__, :enabled?}, false) + end +end diff --git a/engine/lib/engine/search/store/backend.ex b/engine/lib/engine/search/store/backend.ex new file mode 100644 index 00000000..042f4942 --- /dev/null +++ b/engine/lib/engine/search/store/backend.ex @@ -0,0 +1,109 @@ +defmodule Lexical.RemoteControl.Search.Store.Backend do + @moduledoc """ + A behaviour for search store backends + """ + alias Lexical.Project + alias Lexical.RemoteControl.Search.Indexer.Entry + @type version :: pos_integer() + + @type priv_state :: term() + @type load_state :: :empty | :stale + @type field_name :: atom() + @type name :: term + @type metadata :: %{ + schema_version: version(), + types: [Entry.entry_type()], + subtypes: [Entry.entry_subtype()] + } + + @type wildcard :: :_ + @type subject_query :: Entry.subject() | wildcard() + @type type_query :: Entry.entry_type() | wildcard() + @type subtype_query :: Entry.entry_subtype() | wildcard() + @type block_structure :: %{Entry.block_id() => block_structure()} | %{} + @type path_structures :: %{Path.t() => block_structure()} + @type accumulator :: any() + @type reducer_fun :: (Entry.t(), accumulator() -> accumulator()) + + @doc """ + Create a new backend. + This function must return quickly, as it's called from the store process + """ + @callback new(Project.t()) :: {:ok, priv_state()} | {:error, any()} + + @doc """ + Prepares the backend for use. + This receives the result of `new/1`, and sets up the store for use. When this function + returns, the backend is considered ready for use. + """ + @callback prepare(priv_state()) :: {:ok, load_state()} + + @doc """ + Synchronizes the backend to the file system (optional) + """ + @callback sync(Project.t()) :: :ok | {:error, any()} + + @doc """ + Inserts all entries into the backend + """ + @callback insert([Entry.t()]) :: :ok + + @doc """ + Drops all data from the backend, but keeps the underlying structure + """ + @callback drop() :: boolean() + + @doc """ + Drops all data from the backend, and disposes of any underlying structure + """ + @callback destroy(Project.t()) :: :ok + + @doc """ + Applies a reducer function to the backend's entries + """ + @callback reduce(accumulator(), reducer_fun()) :: accumulator() + + @doc """ + Replaces all the entries in the store with those passed in + """ + @callback replace_all([Entry.t()]) :: :ok + + @doc """ + Deletes all entries whose path is equal to the one passed in. + """ + @callback delete_by_path(Path.t()) :: {:ok, [Entry.entry_id()]} | {:error, any()} + + @doc """ + Returns the block structure for the given path + """ + @callback structure_for_path(Path.t()) :: {:ok, block_structure()} | :error + + @doc """ + Finds all entries + """ + @callback find_by_subject(subject_query(), type_query(), subtype_query()) :: [Entry.t()] + + @doc """ + Finds all entries by prefix + """ + @callback find_by_prefix(subject_query(), type_query(), subtype_query()) :: [Entry.t()] + + @doc """ + Finds entries whose ref attribute is in the given list + """ + @callback find_by_ids([Entry.entry_id()], type_query(), subtype_query()) :: [Entry.t()] + + @doc """ + Returns all the sibling elements of the given element. + + Elements are returned in the order they appear in the source + """ + @callback siblings(Entry.t()) :: [Entry.t()] + + @doc """ + Returns the parent block of the given entry, or :error if there is no parent + """ + @callback parent(Entry.t()) :: {:ok, Entry.t()} | :error + + @optional_callbacks sync: 1 +end diff --git a/engine/lib/engine/search/store/backends/ets.ex b/engine/lib/engine/search/store/backends/ets.ex new file mode 100644 index 00000000..144fa2eb --- /dev/null +++ b/engine/lib/engine/search/store/backends/ets.ex @@ -0,0 +1,246 @@ +defmodule Lexical.RemoteControl.Search.Store.Backends.Ets do + alias Lexical.Project + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Store.Backend + alias Lexical.RemoteControl.Search.Store.Backends.Ets.State + + use GenServer + + @behaviour Backend + + @impl Backend + def new(%Project{}) do + {:ok, Process.whereis(__MODULE__)} + end + + @impl Backend + def prepare(pid) do + GenServer.call(pid, :prepare, :infinity) + end + + @impl Backend + def insert(entries) do + GenServer.call(genserver_name(), {:insert, [entries]}, :infinity) + end + + @impl Backend + def drop do + GenServer.call(genserver_name(), {:drop, []}) + end + + @impl Backend + def destroy(%Project{} = project) do + name = genserver_name(project) + + if pid = GenServer.whereis(name) do + GenServer.call(pid, {:destroy, []}) + end + + :ok + end + + def destroy_all(%Project{} = project) do + State.destroy_all(project) + end + + @impl Backend + def reduce(acc, reducer_fun) do + GenServer.call(genserver_name(), {:reduce, [acc, reducer_fun]}, :infinity) + end + + @impl Backend + def replace_all(entries) do + GenServer.call(genserver_name(), {:replace_all, [entries]}, :infinity) + end + + @impl Backend + def delete_by_path(path) do + GenServer.call(genserver_name(), {:delete_by_path, [path]}) + end + + @impl Backend + def find_by_subject(subject, type, subtype) do + GenServer.call(genserver_name(), {:find_by_subject, [subject, type, subtype]}) + end + + @impl Backend + def find_by_prefix(prefix, type, subtype) do + GenServer.call(genserver_name(), {:find_by_prefix, [prefix, type, subtype]}) + end + + @impl Backend + def find_by_ids(ids, type, subtype) do + GenServer.call(genserver_name(), {:find_by_ids, [ids, type, subtype]}) + end + + @impl Backend + def structure_for_path(path) do + GenServer.call(genserver_name(), {:structure_for_path, [path]}) + end + + @impl Backend + def siblings(%Entry{} = entry) do + GenServer.call(genserver_name(), {:siblings, [entry]}) + end + + @impl Backend + def parent(%Entry{} = entry) do + GenServer.call(genserver_name(), {:parent, [entry]}) + end + + def start_link(%Project{} = project) do + GenServer.start_link(__MODULE__, [project], name: __MODULE__) + end + + def start_link do + start_link(RemoteControl.get_project()) + end + + def child_spec([%Project{}] = init_args) do + %{id: __MODULE__, start: {__MODULE__, :start_link, init_args}} + end + + def child_spec(_) do + child_spec([RemoteControl.get_project()]) + end + + @impl GenServer + def init([%Project{} = project]) do + Process.flag(:fullsweep_after, 5) + :ok = connect_to_project_nodes(project) + {:ok, project, {:continue, :try_for_leader}} + end + + @impl GenServer + def handle_continue(:try_for_leader, %Project{} = project) do + leader_name = leader_name(project) + + with :undefined <- :global.whereis_name(leader_name), + :ok <- become_leader(project) do + {:noreply, create_leader(project)} + else + _ -> + {:noreply, follow_leader(project)} + end + end + + @impl GenServer + def handle_call(:prepare, _from, %State{} = state) do + case State.prepare(state) do + {:error, :not_leader} = error -> + {:stop, :normal, error, state} + + {reply, new_state} -> + {:reply, reply, new_state} + end + end + + def handle_call({function_name, arguments}, _from, %State{} = state) do + arguments = [state | arguments] + reply = apply(State, function_name, arguments) + {:reply, reply, state} + end + + @impl GenServer + def handle_info({:EXIT, _, _reason}, %State{leader?: true} = state) do + # ets died, and we own it. Restart it + + {:noreply, create_leader(state.project)} + end + + def handle_info({:DOWN, _ref, :process, pid, _reason}, %State{leader_pid: pid} = state) do + {:noreply, state.project, {:continue, :try_for_leader}} + end + + def handle_info({:global_name_conflict, {:ets_search, _}}, %State{} = state) do + # This clause means we were randomly notified by the call to + # :global.random_notify_name. We've been selected to be the leader! + new_state = become_leader(state.project) + {:noreply, new_state} + end + + def handle_info(:gc, %State{} = state) do + :erlang.garbage_collect() + schedule_gc() + {:noreply, state} + end + + @impl GenServer + def terminate(_reason, %State{} = state) do + State.terminate(state) + state + end + + # Private + + defp leader_name(%Project{} = project) do + {:ets_search, Project.name(project)} + end + + defp genserver_name do + genserver_name(RemoteControl.get_project()) + end + + defp genserver_name(%Project{} = project) do + {:global, leader_name(project)} + end + + defp become_leader(%Project{} = project) do + leader_name = leader_name(project) + :global.trans(leader_name, fn -> do_become_leader(project) end, [], 0) + end + + defp do_become_leader(%Project{} = project) do + leader_name = leader_name(project) + + with :undefined <- :global.whereis_name(leader_name), + :yes <- :global.register_name(leader_name, self(), &:global.random_notify_name/3) do + Process.flag(:trap_exit, true) + :ok + else + _ -> + :error + end + end + + defp follow_leader(%Project{} = project) do + leader_pid = :global.whereis_name(leader_name(project)) + Process.monitor(leader_pid) + State.new_follower(project, leader_pid) + end + + defp create_leader(%Project{} = project) do + State.new_leader(project) + end + + defp connect_to_project_nodes(%Project{} = project) do + case :erl_epmd.names() do + {:ok, node_names_and_ports} -> + project + |> project_nodes(node_names_and_ports) + |> Enum.each(&Node.connect/1) + + :global.sync() + + _ -> + :ok + end + end + + defp project_nodes(%Project{} = project, node_and_port_list) do + project_name = Project.name(project) + + project_substring = "project-#{project_name}-" + + for {node_name_charlist, _port} <- node_and_port_list, + node_name_string = List.to_string(node_name_charlist), + String.contains?(node_name_string, project_substring) do + :"#{node_name_string}@127.0.0.1" + end + end + + defp schedule_gc do + Process.send_after(self(), :gc, :timer.seconds(5)) + end +end diff --git a/engine/lib/engine/search/store/backends/ets/schema.ex b/engine/lib/engine/search/store/backends/ets/schema.ex new file mode 100644 index 00000000..0c9e7ad7 --- /dev/null +++ b/engine/lib/engine/search/store/backends/ets/schema.ex @@ -0,0 +1,229 @@ +defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Schema do + @moduledoc """ + A use-able module that allows ETS schemas to be created and migrated. + + This module allows users to define ETS key-based schemas for our search backends. These modules + are versioned, and are all stored in their own ETS tables. This is so that a single ETS table can + never have more than one schema. + + Schemas also support migrations. An optional `migrate` function receives old entries and is expected + transform them into the newer version. The results of this function will be loaded into the schema's + ETS table. If an empty list is returned, a full reindex will take place. + """ + defmacro __using__(opts) do + version = Keyword.fetch!(opts, :version) + + quote do + @behaviour unquote(__MODULE__) + @version unquote(version) + alias Lexical.Project + import unquote(__MODULE__), only: [defkey: 2] + + def version do + @version + end + + def index_file_name do + "source.index.v#{@version}.ets" + end + + def table_name do + :"lexical_search_v#{@version}" + end + + def table_options do + [:named_table, :set] + end + + def migrate(entries) do + {:ok, entries} + end + + defoverridable migrate: 1, index_file_name: 0, table_options: 0 + end + end + + alias Lexical.Project + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Store.Backends.Ets.Wal + + import Wal, only: :macros + + @type write_concurrency_alternative :: boolean() | :auto + @type table_tweak :: + :compressed + | {:write_concurrency, write_concurrency_alternative()} + | {:read_concurrency, boolean()} + | {:decentralized_counters, boolean()} + + @type table_option :: :ets.table_type() | table_tweak() + + @type key :: tuple() + @type row :: {key, tuple()} + + @callback index_file_name() :: String.t() + @callback table_options() :: [table_option()] + @callback to_rows(Entry.t()) :: [row()] + @callback migrate([Entry.t()]) :: {:ok, [row()]} | {:error, term()} + + defmacro defkey(name, fields) do + query_keys = Enum.map(fields, fn name -> {name, :_} end) + query_record_name = :"query_#{name}" + + quote location: :keep do + require Record + + Record.defrecord(unquote(name), unquote(fields)) + Record.defrecord(unquote(query_record_name), unquote(name), unquote(query_keys)) + end + end + + @spec entries_to_rows(Enumerable.t(Entry.t()), module()) :: [tuple()] + def entries_to_rows(entries, schema_module) do + entries + |> Stream.flat_map(&schema_module.to_rows(&1)) + |> Enum.reduce(%{}, fn {key, value}, acc -> + Map.update(acc, key, [value], fn old_values -> [value | old_values] end) + end) + |> Enum.to_list() + end + + def load(%Project{} = project, schema_order) do + ensure_unique_versions(schema_order) + + with {:ok, initial_schema, chain} <- upgrade_chain(project, schema_order), + {:ok, wal, table_name, entries} <- load_initial_schema(project, initial_schema) do + handle_upgrade_chain(chain, project, wal, table_name, entries) + else + _ -> + schema_module = List.last(schema_order) + table_name = schema_module.table_name() + ensure_schema_table_exists(table_name, schema_module.table_options()) + + {:ok, new_wal} = Wal.load(project, schema_module.version(), schema_module.table_name()) + + {:ok, new_wal, table_name, :empty} + end + end + + defp load_status([]), do: :empty + defp load_status(_entries), do: :stale + + defp handle_upgrade_chain([_schema_module], _project, wal, table_name, entries) do + # this case is that there are no migrations to perform + # we get a single entry, which is the schema module + + {:ok, wal, table_name, load_status(entries)} + end + + defp handle_upgrade_chain(chain, project, _wal, _table_name, entries) do + with {:ok, schema_module, entries} <- apply_migrations(project, chain, entries), + {:ok, new_wal, dest_table_name} <- populate_schema_table(project, schema_module, entries) do + {:ok, new_wal, dest_table_name, load_status(entries)} + end + end + + defp apply_migrations(_project, [initial], entries) do + {:ok, initial, entries} + end + + defp apply_migrations(project, chain, entries) do + Enum.reduce_while(chain, {:ok, nil, entries}, fn + initial, {:ok, nil, entries} -> + Wal.destroy(project, initial.version()) + {:cont, {:ok, initial, entries}} + + to, {:ok, _, entries} -> + case to.migrate(entries) do + {:ok, new_entries} -> + Wal.destroy(project, to.version()) + {:cont, {:ok, to, new_entries}} + + error -> + {:halt, error} + end + end) + end + + defp populate_schema_table(%Project{} = project, schema_module, entries) do + dest_table_name = schema_module.table_name() + ensure_schema_table_exists(dest_table_name, schema_module.table_options()) + + with {:ok, wal} <- Wal.load(project, schema_module.version(), dest_table_name), + {:ok, new_wal_state} <- do_populate_schema(wal, dest_table_name, entries), + {:ok, checkpoint_wal} <- Wal.checkpoint(new_wal_state) do + {:ok, checkpoint_wal, dest_table_name} + end + end + + defp do_populate_schema(%Wal{} = wal, table_name, entries) do + result = + with_wal wal do + :ets.delete_all_objects(table_name) + :ets.insert(table_name, entries) + end + + case result do + {:ok, new_wal_state, _} -> {:ok, new_wal_state} + error -> error + end + end + + defp ensure_schema_table_exists(table_name, table_options) do + case :ets.whereis(table_name) do + :undefined -> :ets.new(table_name, table_options) + _ -> table_name + end + end + + defp load_initial_schema(%Project{} = project, schema_module) do + table_name = schema_module.table_name() + ensure_schema_table_exists(table_name, schema_module.table_options()) + + case Wal.load(project, schema_module.version(), table_name) do + {:ok, wal} -> {:ok, wal, table_name, :ets.tab2list(table_name)} + error -> error + end + end + + defp upgrade_chain(%Project{} = project, schema_order) do + {_, initial_schema, schemas} = + schema_order + |> Enum.reduce({:not_found, nil, []}, fn + schema_module, {:not_found, nil, _} -> + if Wal.exists?(project, schema_module.version()) do + {:found, schema_module, [schema_module]} + else + {:not_found, nil, []} + end + + schema_module, {:found, initial_schema, chain} -> + {:found, initial_schema, [schema_module | chain]} + end) + + case Enum.reverse(schemas) do + [] -> + :error + + other -> + {:ok, initial_schema, other} + end + end + + defp ensure_unique_versions(schemas) do + Enum.reduce(schemas, %{}, fn schema, seen_versions -> + schema_version = schema.version() + + case seen_versions do + %{^schema_version => previous_schema} -> + message = + "Version Conflict. #{inspect(schema)} had a version that matches #{inspect(previous_schema)}" + + raise ArgumentError.exception(message) + + _ -> + Map.put(seen_versions, schema_version, schema) + end + end) + end +end diff --git a/engine/lib/engine/search/store/backends/ets/schemas/legacy_v0.ex b/engine/lib/engine/search/store/backends/ets/schemas/legacy_v0.ex new file mode 100644 index 00000000..57253244 --- /dev/null +++ b/engine/lib/engine/search/store/backends/ets/schemas/legacy_v0.ex @@ -0,0 +1,19 @@ +defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Schemas.LegacyV0 do + @moduledoc """ + A legacy version of the schema. + + We pushed the initial indexer to main before we added schemas and versioning. + This represents that schema type, hence the non-versioned name. + """ + alias Lexical.RemoteControl.Search.Store.Backends.Ets.Schema + + use Schema, version: 0 + + def index_file_name do + "source.index.ets" + end + + def to_rows(_) do + [] + end +end diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v1.ex b/engine/lib/engine/search/store/backends/ets/schemas/v1.ex new file mode 100644 index 00000000..5653a3ec --- /dev/null +++ b/engine/lib/engine/search/store/backends/ets/schemas/v1.ex @@ -0,0 +1,79 @@ +defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Schemas.V1 do + @moduledoc """ + This schema uses a bit of data duplication in order to achieve good performance. + + It does this by storing data under three different key types. The first type groups references to ids by + path, and is accessible via the `by_path` utility macros. The second, stores data by subject, type, subtype, + path and the elixir and erlang versions. This is what powers exact matching. + Finally, entries are stored by their id, which powers direct lookups, which are used in fuzzy matching. + + """ + + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Store.Backends.Ets.Schema + + use Schema, version: 1 + + defkey :by_id, [:id, :type, :subtype] + + defkey :by_subject, [ + :subject, + :type, + :subtype, + :path + ] + + defkey :by_path, [:path] + + def migrate(entries) do + migrated = + entries + |> Stream.filter(fn + {_, %_{type: _, subtype: _, id: _}} -> true + _ -> false + end) + |> Stream.map(fn {_, entry} -> entry end) + |> Schema.entries_to_rows(__MODULE__) + + {:ok, migrated} + end + + def to_rows(%Entry{} = entry) do + subject_key = + by_subject( + subject: to_subject(entry.subject), + type: entry.type, + subtype: entry.subtype, + path: entry.path + ) + + id_key = + by_id( + id: entry.id, + type: entry.type, + subtype: entry.subtype + ) + + path_key = by_path(path: entry.path) + + [{subject_key, id_key}, {id_key, entry}, {path_key, id_key}] + end + + # This case will handle any namespaced entries + def to_rows(%{type: _, subtype: _, id: _} = entry) do + map = Map.delete(entry, :__struct__) + + Entry + |> struct(map) + |> to_rows() + end + + def table_options do + [:named_table, :ordered_set] + end + + defp to_subject(binary) when is_binary(binary), do: binary + defp to_subject(:_), do: :_ + defp to_subject(atom) when is_atom(atom), do: inspect(atom) + defp to_subject(other), do: to_string(other) +end diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v2.ex b/engine/lib/engine/search/store/backends/ets/schemas/v2.ex new file mode 100644 index 00000000..ce326b65 --- /dev/null +++ b/engine/lib/engine/search/store/backends/ets/schemas/v2.ex @@ -0,0 +1,69 @@ +defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Schemas.V2 do + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Store.Backends.Ets.Schema + + require Entry + use Schema, version: 2 + + defkey :by_id, [:id, :type, :subtype] + + defkey :by_subject, [ + :subject, + :type, + :subtype, + :path + ] + + defkey :by_path, [:path] + defkey :by_block_id, [:block_id, :path] + defkey :structure, [:path] + + def migrate(_) do + {:ok, []} + end + + def to_rows(%Entry{} = entry) when Entry.is_structure(entry) do + structure_key = structure(path: entry.path) + [{structure_key, entry.subject}] + end + + def to_rows(%Entry{} = entry) do + subject_key = + by_subject( + subject: to_subject(entry.subject), + type: entry.type, + subtype: entry.subtype, + path: entry.path + ) + + id_key = + by_id( + id: entry.id, + type: entry.type, + subtype: entry.subtype + ) + + path_key = by_path(path: entry.path) + block_key = by_block_id(path: entry.path, block_id: entry.block_id) + + [{id_key, entry}, {subject_key, id_key}, {path_key, id_key}, {block_key, id_key}] + end + + # This case will handle any namespaced entries + def to_rows(%{type: _, subtype: _, id: _} = entry) do + map = Map.delete(entry, :__struct__) + + Entry + |> struct(map) + |> to_rows() + end + + def table_options do + [:named_table, :ordered_set, :compressed] + end + + defp to_subject(binary) when is_binary(binary), do: binary + defp to_subject(:_), do: :_ + defp to_subject(atom) when is_atom(atom), do: inspect(atom) + defp to_subject(other), do: to_string(other) +end diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v3.ex b/engine/lib/engine/search/store/backends/ets/schemas/v3.ex new file mode 100644 index 00000000..98c36f77 --- /dev/null +++ b/engine/lib/engine/search/store/backends/ets/schemas/v3.ex @@ -0,0 +1,82 @@ +defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Schemas.V3 do + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Store.Backends.Ets.Schema + + require Entry + use Schema, version: 3 + + defkey :by_id, [:id, :type, :subtype] + + defkey :by_subject, [ + :subject, + :type, + :subtype, + :path + ] + + defkey :by_path, [:path] + defkey :by_block_id, [:block_id, :path] + defkey :structure, [:path] + + def migrate(entries) do + migrated = + entries + |> Stream.filter(fn + {query_by_subject(), %Entry{}} -> true + _ -> false + end) + |> Stream.map(fn {_, entry} -> entry end) + |> Schema.entries_to_rows(__MODULE__) + + {:ok, migrated} + end + + def to_rows(%Entry{} = entry) when Entry.is_structure(entry) do + structure_key = structure(path: entry.path) + [{structure_key, entry.subject}] + end + + def to_rows(%Entry{} = entry) do + subject_key = + by_subject( + subject: to_subject(entry.subject), + type: entry.type, + subtype: entry.subtype, + path: entry.path + ) + + id_key = + by_id( + id: entry.id, + type: entry.type, + subtype: entry.subtype + ) + + path_key = by_path(path: entry.path) + block_key = by_block_id(path: entry.path, block_id: entry.block_id) + + [{id_key, entry}, {subject_key, id_key}, {path_key, id_key}, {block_key, id_key}] + end + + # This case will handle any namespaced entries + def to_rows(%{type: _, subtype: _, id: _} = entry) do + map = Map.delete(entry, :__struct__) + + Entry + |> struct(map) + |> to_rows() + end + + def table_options do + if Features.can_use_compressed_ets_table?() do + [:named_table, :ordered_set, :compressed] + else + [:named_table, :ordered_set] + end + end + + def to_subject(charlist) when is_list(charlist), do: charlist + def to_subject(:_), do: :_ + def to_subject(atom) when is_atom(atom), do: atom |> inspect() |> to_charlist() + def to_subject(other), do: to_charlist(other) +end diff --git a/engine/lib/engine/search/store/backends/ets/state.ex b/engine/lib/engine/search/store/backends/ets/state.ex new file mode 100644 index 00000000..08891fa3 --- /dev/null +++ b/engine/lib/engine/search/store/backends/ets/state.ex @@ -0,0 +1,297 @@ +defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.State do + @moduledoc """ + An ETS based search backend + + This backend uses an ETS table to store its data using a schema defined in the schemas submodule. + + """ + alias Lexical.Project + alias Lexical.RemoteControl.Search.Indexer.Entry + alias Lexical.RemoteControl.Search.Store.Backends.Ets.Schema + alias Lexical.RemoteControl.Search.Store.Backends.Ets.Schemas + alias Lexical.RemoteControl.Search.Store.Backends.Ets.Wal + + @schema_order [ + Schemas.LegacyV0, + Schemas.V1, + Schemas.V2, + Schemas.V3 + ] + + import Wal, only: :macros + import Entry, only: :macros + + import Schemas.V3, + only: [ + by_block_id: 1, + query_by_id: 1, + query_by_path: 1, + query_structure: 1, + query_by_subject: 1, + structure: 1, + to_subject: 1 + ] + + defstruct [:project, :table_name, :leader?, :leader_pid, :wal_state] + + def new_leader(%Project{} = project) do + %__MODULE__{project: project, leader?: true, leader_pid: self()} + end + + def new_follower(%Project{} = project, leader_pid) do + %__MODULE__{project: project, leader?: false, leader_pid: leader_pid} + end + + def prepare(%__MODULE__{leader?: true} = state) do + {:ok, wal, table_name, result} = Schema.load(state.project, @schema_order) + + {{:ok, result}, %__MODULE__{state | table_name: table_name, wal_state: wal}} + end + + def prepare(%__MODULE__{leader?: false}) do + {:error, :not_leader} + end + + def drop(%__MODULE__{leader?: true} = state) do + Wal.truncate(state.wal_state) + :ets.delete_all_objects(state.table_name) + end + + def insert(%__MODULE__{leader?: true} = state, entries) do + rows = Schema.entries_to_rows(entries, current_schema()) + + with_wal state.wal_state do + true = :ets.insert(state.table_name, rows) + end + + :ok + end + + def reduce(%__MODULE__{} = state, acc, reducer_fun) do + ets_reducer = fn + {{:by_id, _, _, _}, entries}, acc when is_list(entries) -> + Enum.reduce(entries, acc, reducer_fun) + + {{:by_id, _, _, _}, %Entry{} = entry}, acc -> + reducer_fun.(entry, acc) + + _, acc -> + acc + end + + :ets.foldl(ets_reducer, acc, state.table_name) + end + + def find_by_subject(%__MODULE__{} = state, subject, type, subtype) do + match_pattern = + query_by_subject( + subject: to_subject(subject), + type: type, + subtype: subtype + ) + + state.table_name + |> :ets.match_object({match_pattern, :_}) + |> Enum.flat_map(fn {_, id_keys} -> + id_keys + end) + |> MapSet.new() + |> Enum.flat_map(&:ets.lookup_element(state.table_name, &1, 2)) + end + + def find_by_prefix(%__MODULE__{} = state, subject, type, subtype) do + match_pattern = + query_by_subject( + subject: to_prefix(subject), + type: type, + subtype: subtype + ) + + state.table_name + |> :ets.select([{{match_pattern, :_}, [], [:"$_"]}]) + |> Stream.flat_map(fn {_, id_keys} -> id_keys end) + |> Stream.uniq() + |> Enum.flat_map(&:ets.lookup_element(state.table_name, &1, 2)) + end + + @dialyzer {:nowarn_function, to_prefix: 1} + + defp to_prefix(prefix) when is_binary(prefix) do + # what we really want to do here is convert the prefix to a improper list + # like this: `'abc' -> [97, 98, 99 | :_]`, it's different from `'abc' ++ [:_]` + # this is the required format for the `:ets.select` function. + {last_char, others} = prefix |> String.to_charlist() |> List.pop_at(-1) + others ++ [last_char | :_] + end + + def siblings(%__MODULE__{} = state, %Entry{} = entry) do + key = by_block_id(block_id: entry.block_id, path: entry.path) + + siblings = + state.table_name + |> :ets.lookup_element(key, 2) + |> Enum.map(&:ets.lookup_element(state.table_name, &1, 2)) + |> List.flatten() + |> Enum.filter(fn sibling -> + case {is_block(entry), is_block(sibling)} do + {same, same} -> true + _ -> false + end + end) + |> Enum.sort_by(& &1.id) + |> Enum.uniq() + + {:ok, siblings} + rescue + ArgumentError -> + :error + end + + def parent(%__MODULE__{} = state, %Entry{} = entry) do + with {:ok, structure} <- structure_for_path(state, entry.path), + {:ok, child_path} <- child_path(structure, entry.block_id) do + child_path = + if is_block(entry) do + # if we're a block, finding the first block will find us, so pop + # our id off the path. + tl(child_path) + else + child_path + end + + find_first_by_block_id(state, child_path) + end + end + + def parent(%__MODULE__{}, :root) do + :error + end + + def find_by_ids(%__MODULE__{} = state, ids, type, subtype) + when is_list(ids) do + for id <- ids, + match_pattern = match_id_key(id, type, subtype), + {_key, entry} <- :ets.match_object(state.table_name, match_pattern) do + entry + end + |> List.flatten() + end + + def replace_all(%__MODULE__{leader?: true} = state, entries) do + rows = Schema.entries_to_rows(entries, current_schema()) + + {:ok, _, result} = + with_wal state.wal_state do + true = :ets.delete_all_objects(state.table_name) + true = :ets.insert(state.table_name, rows) + :ok + end + + # When we replace everything, the old checkpoint is invalidated + # so it makes sense to force a new one. + Wal.checkpoint(state.wal_state) + result + end + + def delete_by_path(%__MODULE__{leader?: true} = state, path) do + ids_to_delete = + state.table_name + |> :ets.match({query_by_path(path: path), :"$0"}) + |> List.flatten() + + with_wal state.wal_state do + :ets.match_delete(state.table_name, {query_by_subject(path: path), :_}) + :ets.match_delete(state.table_name, {query_by_path(path: path), :_}) + :ets.match_delete(state.table_name, {query_structure(path: path), :_}) + end + + Enum.each(ids_to_delete, fn id -> + with_wal state.wal_state do + :ets.delete(state.table_name, id) + end + end) + + {:ok, ids_to_delete} + end + + def destroy_all(%Project{} = project) do + Wal.destroy_all(project) + end + + def destroy(%__MODULE__{leader?: true, wal_state: %Wal{}} = state) do + Wal.destroy(state.wal_state) + end + + def destroy(%__MODULE__{leader?: true}) do + :ok + end + + def terminate(%__MODULE__{wal_state: %Wal{}} = state) do + Wal.close(state.wal_state) + end + + def terminate(%__MODULE__{}) do + :ok + end + + defp child_path(structure, child_id) do + path = + Enum.reduce_while(structure, [], fn + {^child_id, _children}, children -> + {:halt, [child_id | children]} + + {_, children}, path when map_size(children) == 0 -> + {:cont, path} + + {current_id, children}, path -> + case child_path(children, child_id) do + {:ok, child_path} -> {:halt, [current_id | path] ++ Enum.reverse(child_path)} + :error -> {:cont, path} + end + end) + + case path do + [] -> :error + path -> {:ok, Enum.reverse(path)} + end + end + + defp find_first_by_block_id(%__MODULE__{} = state, block_ids) do + Enum.reduce_while(block_ids, :error, fn block_id, failure -> + case find_entry_by_id(state, block_id) do + {:ok, _} = success -> + {:halt, success} + + _ -> + {:cont, failure} + end + end) + end + + def find_entry_by_id(%__MODULE__{} = state, id) do + case find_by_ids(state, [id], :_, :_) do + [entry] -> {:ok, entry} + _ -> :error + end + end + + def structure_for_path(%__MODULE__{} = state, path) do + key = structure(path: path) + + case :ets.lookup_element(state.table_name, key, 2) do + [structure] -> {:ok, structure} + _ -> :error + end + rescue + ArgumentError -> + :error + end + + defp match_id_key(id, type, subtype) do + {query_by_id(id: id, type: type, subtype: subtype), :_} + end + + defp current_schema do + List.last(@schema_order) + end +end diff --git a/engine/lib/engine/search/store/backends/ets/wal.ex b/engine/lib/engine/search/store/backends/ets/wal.ex new file mode 100644 index 00000000..ef092838 --- /dev/null +++ b/engine/lib/engine/search/store/backends/ets/wal.ex @@ -0,0 +1,423 @@ +defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Wal do + @moduledoc """ + A (hopefully) simple write-ahead log + """ + alias Lexical.Identifier + alias Lexical.Project + alias Lexical.VM.Versions + + import Record + + defrecord :operation, id: nil, function: nil, args: nil + + defstruct [ + :checkpoint_version, + :ets_table, + :max_wal_operations, + :project, + :schema_version, + :update_log, + :update_log_name + ] + + @write_functions [ + :delete, + :delete_all_objects, + :delete_object, + :insert, + :insert_new, + :match_delete, + :select_delete, + :select_replace, + :update_counter, + :update_element + ] + + @no_checkpoint_id 0 + @chunk_size 10_000 + @checkpoint_int_length 20 + @default_max_operations 50_000 + + defmacro with_wal(wal_state, do: block) do + {_, write_calls} = + Macro.prewalk(block, [], fn ast, acc -> + {ast, collect_ets_writes(ast, acc)} + end) + + operations = + write_calls + |> Enum.reverse() + |> Enum.map(&to_operation/1) + + quote do + case unquote(__MODULE__).append(unquote(wal_state), unquote(operations)) do + {:ok, wal_state} -> + result = unquote(block) + {:ok, wal_state, result} + + error -> + error + end + end + end + + def load(%Project{} = project, schema_version, ets_table, options \\ []) do + max_wal_operations = Keyword.get(options, :max_wal_operations, @default_max_operations) + + wal = %__MODULE__{ + ets_table: ets_table, + max_wal_operations: max_wal_operations, + project: project, + schema_version: to_string(schema_version) + } + + ensure_wal_directory_exists(wal) + + with {:ok, checkpoint_id} <- load_latest_checkpoint(wal), + {:ok, new_wal} <- open_update_wal(wal, checkpoint_id), + :ok <- apply_updates(new_wal) do + {:ok, new_wal} + end + end + + def exists?(%__MODULE__{} = wal) do + exists?(wal.project, wal.schema_version) + end + + def exists?(%Project{} = project, schema_vesion) do + case File.ls(wal_directory(project, schema_vesion)) do + {:ok, [_]} -> true + {:ok, [_ | _]} -> true + _ -> false + end + end + + def append(%__MODULE__{} = wal, operations) do + case :disk_log.log_terms(wal.update_log, operations) do + :ok -> + maybe_checkpoint(wal) + + error -> + error + end + end + + def close(%__MODULE__{} = wal) do + case wal.update_log do + nil -> + :ok + + log -> + :disk_log.sync(log) + :disk_log.close(log) + end + end + + def truncate(%__MODULE__{} = wal) do + :disk_log.truncate(wal.update_log) + end + + def destroy(%__MODULE__{} = wal) do + close(wal) + destroy(wal.project, wal.schema_version) + end + + def destroy(%Project{} = project, schema_version) do + project + |> wal_directory(schema_version) + |> File.rm_rf!() + end + + def destroy_all(%Project{} = project) do + project + |> root_path() + |> File.rm_rf!() + end + + def checkpoint(%__MODULE__{} = wal) do + case :ets.info(wal.ets_table) do + :undefined -> + {:error, :no_table} + + _ -> + do_checkpoint(wal) + end + end + + def size(%__MODULE__{update_log: nil}) do + {:error, :not_loaded} + end + + def size(%__MODULE__{update_log: update_log}) do + with info when is_list(info) <- :disk_log.info(update_log), + {:ok, size} <- Keyword.fetch(info, :items) do + {:ok, size} + else + _ -> + {:error, :not_loaded} + end + end + + def root_path(%Project{} = project) do + Project.workspace_path(project, ["indexes", "ets"]) + end + + # Private + + defp collect_ets_writes({{:., _, [:ets, function_name]}, _, args}, acc) + when function_name in @write_functions do + [{:ets, function_name, args} | acc] + end + + defp collect_ets_writes(_, acc), do: acc + + defp to_operation({:ets, call_name, args}) do + quote do + operation(id: Identifier.next_global!(), function: unquote(call_name), args: unquote(args)) + end + end + + defp ensure_wal_directory_exists(%__MODULE__{} = wal) do + wal |> wal_directory() |> File.mkdir_p!() + end + + defp wal_directory(%__MODULE__{} = wal) do + wal_directory(wal.project, wal.schema_version) + end + + defp wal_directory(%Project{} = project, schema_version) do + versions = Versions.current() + Path.join([root_path(project), versions.erlang, versions.elixir, to_string(schema_version)]) + end + + defp open_update_wal(%__MODULE__{} = wal, checkpoint_version) do + wal_path = update_wal_path(wal) + wal_name = update_wal_name(wal) + + case :disk_log.open(name: wal_name, file: String.to_charlist(wal_path)) do + {:ok, log} -> + new_wal = %__MODULE__{ + wal + | update_log: log, + update_log_name: wal_name, + checkpoint_version: checkpoint_version + } + + {:ok, new_wal} + + {:repaired, log, {:recovered, _}, _bad} -> + new_wal = %__MODULE__{ + wal + | update_log: log, + update_log_name: wal_name, + checkpoint_version: checkpoint_version + } + + {:ok, new_wal} + + error -> + error + end + end + + defp update_wal_name(%__MODULE__{} = wal) do + :"updates_for_#{Project.name(wal.project)}_v#{wal.schema_version}" + end + + # Updates + defp apply_updates(%__MODULE__{} = wal) do + stream_updates(wal, wal.update_log, :start) + end + + defp stream_updates(%__MODULE__{} = wal, log, continuation) do + case :disk_log.chunk(log, continuation, @chunk_size) do + {continuation, items} when is_list(items) -> + apply_relevant_items(wal, items) + stream_updates(wal, log, continuation) + + {continuation, items, _bad_bytes} -> + apply_relevant_items(wal, items) + stream_updates(wal, log, continuation) + + :eof -> + :ok + + {:error, _} = error -> + error + end + end + + defp apply_relevant_items(%__MODULE__{} = wal, items) do + checkpoint_version = wal.checkpoint_version + + items + |> Stream.filter(fn operation(id: id) -> id >= checkpoint_version end) + |> Enum.each(fn operation(function: function, args: args) -> + apply(:ets, function, args) + end) + end + + defp get_wal_operations(%__MODULE__{} = wal) do + stats = :disk_log.info(wal.update_log) + Keyword.get(stats, :items, 0) + end + + # Checkpoints + defp needs_checkpoint?(%__MODULE__{} = wal) do + get_wal_operations(wal) >= wal.max_wal_operations + end + + defp maybe_checkpoint(%__MODULE__{} = wal) do + with true <- needs_checkpoint?(wal), + {:ok, new_wal} <- checkpoint(wal) do + {:ok, new_wal} + else + _ -> + {:ok, wal} + end + end + + defp do_checkpoint(%__MODULE__{} = wal) do + checkpoint_version = Identifier.next_global!() + checkpoint_file_name = checkpoint_file_name(checkpoint_version) + + log_path = wal |> wal_directory() |> Path.join(checkpoint_file_name) + log_name = checkpoint_log_name(wal.project) + + with {:ok, log} <- :disk_log.open(name: log_name, file: String.to_charlist(log_path)), + :ok <- checkpoint_ets_table(wal, log), + :ok <- :disk_log.close(log), + :ok <- :disk_log.truncate(wal.update_log) do + new_wal = %__MODULE__{wal | checkpoint_version: checkpoint_version} + delete_old_checkpoints(new_wal) + {:ok, new_wal} + else + error -> + # Checkpoint loading failed. Give up and start over + delete_old_checkpoints(wal) + error + end + end + + defp checkpoint_ets_table(%__MODULE__{} = wal, log) do + log_chunks = fn + item, {@chunk_size, items} -> + :disk_log.log_terms(log, Enum.reverse(items)) + {1, [item]} + + item, {count, items} -> + {count + 1, [item | items]} + end + + {_count, items} = :ets.foldl(log_chunks, {0, []}, wal.ets_table) + :disk_log.log_terms(log, Enum.reverse(items)) + end + + defp load_latest_checkpoint(%__MODULE__{} = wal) do + with {:ok, checkpoint_file} <- find_latest_checkpoint(wal), + {:ok, checkpoint_version} <- extract_checkpoint_version(checkpoint_file), + :ok <- load_checkpoint(wal, checkpoint_file) do + {:ok, checkpoint_version} + else + _ -> + # There's no checkpoint, or our checkpoint is invalid. Start from scratch. + {:ok, @no_checkpoint_id} + end + end + + defp load_checkpoint(%__MODULE__{} = wal, checkpoint_file) do + log_name = checkpoint_log_name(wal.project) + + case :disk_log.open(name: log_name, file: String.to_charlist(checkpoint_file)) do + {:ok, log} -> + stream_checkpoint(wal, log, :start) + + {:repaired, log, _recovered, _bad_bytes} -> + stream_checkpoint(wal, log, :start) + + error -> + error + end + end + + defp delete_old_checkpoints(%__MODULE__{} = wal) do + current_checkpoint_file_name = checkpoint_file_name(wal.checkpoint_version) + + [wal_directory(wal), "*.checkpoint"] + |> Path.join() + |> Path.wildcard() + |> Enum.each(fn checkpoint -> + if Path.basename(checkpoint) != current_checkpoint_file_name do + File.rm(checkpoint) + end + end) + end + + defp checkpoint_file_name(checkpoint_id) when is_integer(checkpoint_id) do + checkpoint_id + |> Integer.to_string(10) + |> checkpoint_file_name() + end + + defp checkpoint_file_name(checkpoint_id) when is_binary(checkpoint_id) do + String.pad_leading(checkpoint_id, @checkpoint_int_length, "0") <> ".checkpoint" + end + + defp checkpoint_log_name(%Project{} = project) do + :"checkpoint_log_#{Project.name(project)}" + end + + defp stream_checkpoint(%__MODULE__{} = wal, log, continuation) do + case :disk_log.chunk(log, continuation, @chunk_size) do + {continuation, items} when is_list(items) -> + :ets.insert(wal.ets_table, items) + stream_checkpoint(wal, log, continuation) + + {continuation, items, _bad_bytes} -> + :ets.insert(wal.ets_table, items) + stream_checkpoint(wal, log, continuation) + + :eof -> + :disk_log.close(log) + :ok + + {:error, _} = error -> + :disk_log.close(log) + error + end + end + + defp find_latest_checkpoint(%__MODULE__{} = wal) do + checkpoints = + [wal_directory(wal), "*.checkpoint"] + |> Path.join() + |> Path.wildcard() + |> Enum.sort(:desc) + + case checkpoints do + [checkpoint | _] -> + {:ok, checkpoint} + + _ -> + {:error, :no_checkpoint} + end + end + + defp extract_checkpoint_version(checkpoint_path) do + file_name = Path.basename(checkpoint_path) + + with [id_string, _] <- String.split(file_name, "."), + {id, ""} <- Integer.parse(id_string, 10) do + {:ok, id} + else + _ -> + :error + end + end + + defp update_wal_path(%__MODULE__{} = wal) do + wal + |> wal_directory() + |> Path.join("updates.wal") + end +end diff --git a/engine/lib/engine/search/store/state.ex b/engine/lib/engine/search/store/state.ex new file mode 100644 index 00000000..9742282f --- /dev/null +++ b/engine/lib/engine/search/store/state.ex @@ -0,0 +1,260 @@ +defmodule Lexical.RemoteControl.Search.Store.State do + alias Lexical.Project + alias Lexical.RemoteControl.Api.Messages + alias Lexical.RemoteControl.Dispatch + alias Lexical.RemoteControl.Search.Fuzzy + alias Lexical.RemoteControl.Search.Indexer.Entry + + require Logger + import Messages + + defstruct [ + :project, + :backend, + :create_index, + :update_index, + :loaded?, + :fuzzy, + :async_load_ref, + :update_buffer + ] + + def new(%Project{} = project, create_index, update_index, backend) do + %__MODULE__{ + backend: backend, + create_index: create_index, + project: project, + loaded?: false, + update_index: update_index, + update_buffer: %{}, + fuzzy: Fuzzy.from_entries([]) + } + end + + def drop(%__MODULE__{} = state) do + state.backend.drop() + end + + def destroy(%__MODULE__{} = state) do + state.backend.destroy(state) + end + + @doc """ + Asynchronously loads the search state. + + This function returns prior to creating or refreshing the index, which + occurs in a separate process. The caller should listen for a message + of the shape `{ref, result}`, where `ref` matches the state's + `:async_load_ref`. Once received, that result should be passed to + `async_load_complete/2`. + """ + def async_load(%__MODULE__{loaded?: false, async_load_ref: nil} = state) do + {:ok, backend_result} = state.backend.new(state.project) + prepare_backend_async(state, backend_result) + end + + def async_load(%__MODULE__{} = state) do + {:ok, state} + end + + def async_load_complete(%__MODULE__{} = state, result) do + new_state = %__MODULE__{state | loaded?: true, async_load_ref: nil} + + response = + case result do + {:create_index, result} -> + create_index_complete(new_state, result) + + {:update_index, result} -> + update_index_complete(new_state, result) + + :initialize_fuzzy -> + initialize_fuzzy(new_state) + end + + Dispatch.broadcast(project_index_ready(project: state.project)) + response + end + + def replace(%__MODULE__{} = state, entries) do + with :ok <- state.backend.replace_all(entries), + :ok <- maybe_sync(state) do + {:ok, %__MODULE__{state | fuzzy: Fuzzy.from_backend(state.backend)}} + end + end + + def exact(%__MODULE__{} = state, subject, constraints) do + type = Keyword.get(constraints, :type, :_) + subtype = Keyword.get(constraints, :subtype, :_) + + case state.backend.find_by_subject(subject, type, subtype) do + l when is_list(l) -> {:ok, l} + error -> error + end + end + + def prefix(%__MODULE__{} = state, prefix, constraints) do + type = Keyword.get(constraints, :type, :_) + subtype = Keyword.get(constraints, :subtype, :_) + + case state.backend.find_by_prefix(prefix, type, subtype) do + l when is_list(l) -> + {:ok, l} + + error -> + error + end + end + + def fuzzy(%__MODULE__{} = state, subject, constraints) do + case Fuzzy.match(state.fuzzy, subject) do + [] -> + {:ok, []} + + ids -> + type = Keyword.get(constraints, :type, :_) + subtype = Keyword.get(constraints, :subtype, :_) + + case state.backend.find_by_ids(ids, type, subtype) do + l when is_list(l) -> {:ok, l} + error -> error + end + end + end + + def siblings(%__MODULE__{} = state, entry) do + case state.backend.siblings(entry) do + l when is_list(l) -> {:ok, l} + error -> error + end + end + + def parent(%__MODULE__{} = state, entry) do + case state.backend.parent(entry) do + %Entry{} = entry -> {:ok, entry} + error -> error + end + end + + def buffer_updates(%__MODULE__{} = state, path, entries) do + %__MODULE__{state | update_buffer: Map.put(state.update_buffer, path, entries)} + end + + def drop_buffered_updates(%__MODULE__{} = state) do + %__MODULE__{state | update_buffer: %{}} + end + + def flush_buffered_updates(%__MODULE__{update_buffer: buffer} = state) + when map_size(buffer) == 0 do + maybe_sync(state) + {:ok, state} + end + + def flush_buffered_updates(%__MODULE__{} = state) do + result = + Enum.reduce_while(state.update_buffer, state, fn {path, entries}, state -> + case update_nosync(state, path, entries) do + {:ok, new_state} -> + {:cont, new_state} + + error -> + {:halt, error} + end + end) + + with %__MODULE__{} = state <- result, + :ok <- maybe_sync(state) do + {:ok, drop_buffered_updates(state)} + end + end + + def update_nosync(%__MODULE__{} = state, path, entries) do + with {:ok, deleted_ids} <- state.backend.delete_by_path(path), + :ok <- state.backend.insert(entries) do + fuzzy = + state.fuzzy + |> Fuzzy.drop_values(deleted_ids) + |> Fuzzy.add(entries) + + {:ok, %__MODULE__{state | fuzzy: fuzzy}} + end + end + + require Logger + + defp prepare_backend_async(%__MODULE__{async_load_ref: nil} = state, backend_result) do + task = + Task.async(fn -> + case state.backend.prepare(backend_result) do + {:ok, :empty} -> + Logger.info("backend reports empty") + {:create_index, state.create_index.(state.project)} + + {:ok, :stale} -> + Logger.info("backend reports stale") + {:update_index, state.update_index.(state.project, state.backend)} + + {:error, :not_leader} -> + :initialize_fuzzy + + error -> + Logger.error("Could not initialize index due to #{inspect(error)}") + error + end + end) + + %__MODULE__{state | async_load_ref: task.ref} + end + + defp create_index_complete(%__MODULE__{} = state, {:ok, entries}) do + case replace(state, entries) do + {:ok, state} -> + state + + {:error, _} -> + Logger.warning("Could not replace entries") + state + end + end + + defp create_index_complete(%__MODULE__{} = state, {:error, _} = error) do + Logger.warning("Could not create index, got: #{inspect(error)}") + state + end + + defp update_index_complete(%__MODULE__{} = state, {:ok, updated_entries, deleted_paths}) do + starting_state = initialize_fuzzy(%__MODULE__{state | loaded?: true}) + + new_state = + updated_entries + |> Enum.group_by(& &1.path) + |> Enum.reduce(starting_state, fn {path, entry_list}, state -> + {:ok, new_state} = update_nosync(state, path, entry_list) + new_state + end) + + Enum.reduce(deleted_paths, new_state, fn path, state -> + {:ok, new_state} = update_nosync(state, path, []) + new_state + end) + end + + defp update_index_complete(%__MODULE__{} = state, {:error, _} = error) do + Logger.warning("Could not update index, got: #{inspect(error)}") + state + end + + defp maybe_sync(%__MODULE__{} = state) do + if function_exported?(state.backend, :sync, 1) do + state.backend.sync(state.project) + else + :ok + end + end + + defp initialize_fuzzy(%__MODULE__{} = state) do + fuzzy = Fuzzy.from_backend(state.backend) + + %__MODULE__{state | fuzzy: fuzzy} + end +end diff --git a/engine/lib/engine/search/subject.ex b/engine/lib/engine/search/subject.ex new file mode 100644 index 00000000..1e701042 --- /dev/null +++ b/engine/lib/engine/search/subject.ex @@ -0,0 +1,18 @@ +defmodule Lexical.RemoteControl.Search.Subject do + @moduledoc """ + Functions for converting to a search entry's subject field + """ + alias Lexical.Formats + + def module(module) do + module + end + + def module_attribute(_module, attribute_name) do + "@#{attribute_name}" + end + + def mfa(module, function, arity) do + Formats.mfa(module, function, arity) + end +end diff --git a/engine/lib/engine/worker.ex b/engine/lib/engine/worker.ex deleted file mode 100644 index 92817add..00000000 --- a/engine/lib/engine/worker.ex +++ /dev/null @@ -1,64 +0,0 @@ -defmodule Engine.Worker do - use GenServer - - def start_link(arg) do - GenServer.start_link(__MODULE__, arg, name: __MODULE__) - end - - @impl GenServer - def init(_arg) do - working_dir = File.cwd!() - {:ok, %{working_dir: working_dir}} - end - - def enqueue_compiler(opts) do - GenServer.cast(__MODULE__, {:compile, opts}) - end - - defp flush(acc) do - receive do - {:"$gen_cast", {:compile, opts}} -> flush([opts | acc]) - after - 0 -> acc - end - end - - @impl GenServer - def handle_cast({:compile, opts}, state) do - # we essentially compile now and rollup any newer requests to compile, so that we aren't doing 5 compiles - # if we the user saves 5 times after saving one time - flush([]) - from = Keyword.fetch!(opts, :from) - - File.cd!(state.working_dir) - - result = Engine.Worker.compile() - - Process.send(from, {:compiler_result, result}, []) - {:noreply, state} - end - - def compile do - # keep stdout on this node - Process.group_leader(self(), Process.whereis(:user)) - - Mix.Task.clear() - - # load the paths for deps and compile them - # will noop if they are already compiled - # The mix cli basically runs this before any mix task - # we have to rerun because we already ran a mix task - # (mix run), which called this, but we also passed - # --no-compile, so nothing was compiled, but the - # task was not re-enabled it seems - Mix.Task.rerun("deps.loadpaths") - - Mix.Task.rerun("compile", [ - "--ignore-module-conflict", - "--no-protocol-consolidation", - "--return-errors" - ]) - rescue - e -> {:error, e} - end -end From 3e9f90f23d79d8f7621c2176aa1eaec18e63e5c5 Mon Sep 17 00:00:00 2001 From: Mitchell Hanberg Date: Wed, 1 Jan 2025 12:01:42 -0500 Subject: [PATCH 02/12] wip: rename Lexical.RemoteControl to Engine --- engine/lib/engine.ex | 12 ++++++------ engine/lib/engine/analyzer.ex | 10 +++++----- engine/lib/engine/analyzer/aliases.ex | 2 +- engine/lib/engine/analyzer/imports.ex | 6 +++--- engine/lib/engine/analyzer/requires.ex | 2 +- engine/lib/engine/analyzer/uses.ex | 2 +- engine/lib/engine/api.ex | 6 +++--- engine/lib/engine/api/messages.ex | 2 +- engine/lib/engine/api/proxy.ex | 18 +++++++++--------- engine/lib/engine/api/proxy/buffering_state.ex | 10 +++++----- engine/lib/engine/api/proxy/draining_state.ex | 8 ++++---- engine/lib/engine/api/proxy/proxying_state.ex | 4 ++-- engine/lib/engine/api/proxy/records.ex | 2 +- engine/lib/engine/application.ex | 6 +++--- engine/lib/engine/bootstrap.ex | 4 ++-- engine/lib/engine/build.ex | 8 ++++---- engine/lib/engine/build/capture_io.ex | 4 ++-- engine/lib/engine/build/capture_server.ex | 2 +- engine/lib/engine/build/document.ex | 8 ++++---- engine/lib/engine/build/document/compiler.ex | 2 +- .../engine/build/document/compilers/config.ex | 6 +++--- .../lib/engine/build/document/compilers/eex.ex | 8 ++++---- .../engine/build/document/compilers/elixir.ex | 6 +++--- .../engine/build/document/compilers/heex.ex | 6 +++--- .../engine/build/document/compilers/no_op.ex | 4 ++-- .../engine/build/document/compilers/quoted.ex | 8 ++++---- engine/lib/engine/build/error.ex | 4 ++-- engine/lib/engine/build/error/location.ex | 2 +- engine/lib/engine/build/error/parse.ex | 4 ++-- engine/lib/engine/build/isolation.ex | 2 +- engine/lib/engine/build/project.ex | 10 +++++----- engine/lib/engine/build/state.ex | 10 +++++----- engine/lib/engine/code_action.ex | 6 +++--- engine/lib/engine/code_action/diagnostic.ex | 2 +- engine/lib/engine/code_action/handler.ex | 6 +++--- .../engine/code_action/handlers/add_alias.ex | 18 +++++++++--------- .../code_action/handlers/organize_aliases.ex | 6 +++--- .../handlers/remove_unused_alias.ex | 8 ++++---- .../handlers/replace_remote_function.ex | 10 +++++----- .../handlers/replace_with_underscore.ex | 6 +++--- .../lib/engine/code_intelligence/definition.ex | 8 ++++---- engine/lib/engine/code_intelligence/docs.ex | 6 +++--- .../lib/engine/code_intelligence/docs/entry.ex | 2 +- engine/lib/engine/code_intelligence/entity.ex | 4 ++-- .../lib/engine/code_intelligence/references.ex | 14 +++++++------- engine/lib/engine/code_intelligence/structs.ex | 10 +++++----- engine/lib/engine/code_intelligence/symbols.ex | 12 ++++++------ .../code_intelligence/symbols/document.ex | 4 ++-- .../code_intelligence/symbols/workspace.ex | 4 ++-- .../lib/engine/code_intelligence/variable.ex | 6 +++--- engine/lib/engine/code_mod/aliases.ex | 4 ++-- engine/lib/engine/code_mod/diff.ex | 2 +- engine/lib/engine/code_mod/format.ex | 8 ++++---- engine/lib/engine/commands/reindex.ex | 12 ++++++------ engine/lib/engine/compilation/tracer.ex | 8 ++++---- engine/lib/engine/completion.ex | 8 ++++---- engine/lib/engine/completion/candidate.ex | 4 ++-- .../completion/candidate/argument_names.ex | 2 +- engine/lib/engine/dispatch.ex | 12 ++++++------ engine/lib/engine/dispatch/handler.ex | 8 ++++---- .../lib/engine/dispatch/handlers/indexing.ex | 10 +++++----- engine/lib/engine/dispatch/pub_sub.ex | 2 +- engine/lib/engine/mix.ex | 4 ++-- engine/lib/engine/module/loader.ex | 2 +- engine/lib/engine/module_mappings.ex | 6 +++--- engine/lib/engine/modules.ex | 4 ++-- engine/lib/engine/plugin.ex | 8 ++++---- engine/lib/engine/plugin/discovery.ex | 6 +++--- engine/lib/engine/plugin/runner.ex | 6 +++--- engine/lib/engine/plugin/runner/coordinator.ex | 4 ++-- .../engine/plugin/runner/coordinator/state.ex | 4 ++-- engine/lib/engine/plugin/supervisor.ex | 2 +- engine/lib/engine/port.ex | 4 ++-- engine/lib/engine/progress.ex | 6 +++--- engine/lib/engine/project_node.ex | 6 +++--- engine/lib/engine/project_node_supervisor.ex | 4 ++-- engine/lib/engine/search/fuzzy.ex | 8 ++++---- engine/lib/engine/search/fuzzy/scorer.ex | 2 +- engine/lib/engine/search/indexer.ex | 10 +++++----- engine/lib/engine/search/indexer/entry.ex | 4 ++-- .../search/indexer/extractors/ecto_schema.ex | 10 +++++----- .../search/indexer/extractors/ex_unit.ex | 10 +++++----- .../indexer/extractors/function_definition.ex | 10 +++++----- .../indexer/extractors/function_reference.ex | 14 +++++++------- .../engine/search/indexer/extractors/module.ex | 14 +++++++------- .../indexer/extractors/module_attribute.ex | 10 +++++----- .../indexer/extractors/struct_definition.ex | 8 ++++---- .../indexer/extractors/struct_reference.ex | 10 +++++----- .../search/indexer/extractors/variable.ex | 8 ++++---- engine/lib/engine/search/indexer/metadata.ex | 2 +- engine/lib/engine/search/indexer/module.ex | 4 ++-- engine/lib/engine/search/indexer/quoted.ex | 4 ++-- engine/lib/engine/search/indexer/source.ex | 4 ++-- .../lib/engine/search/indexer/source/block.ex | 2 +- .../engine/search/indexer/source/reducer.ex | 10 +++++----- engine/lib/engine/search/store.ex | 14 +++++++------- engine/lib/engine/search/store/backend.ex | 4 ++-- engine/lib/engine/search/store/backends/ets.ex | 10 +++++----- .../engine/search/store/backends/ets/schema.ex | 6 +++--- .../store/backends/ets/schemas/legacy_v0.ex | 4 ++-- .../search/store/backends/ets/schemas/v1.ex | 6 +++--- .../search/store/backends/ets/schemas/v2.ex | 6 +++--- .../search/store/backends/ets/schemas/v3.ex | 6 +++--- .../engine/search/store/backends/ets/state.ex | 10 +++++----- .../engine/search/store/backends/ets/wal.ex | 2 +- engine/lib/engine/search/store/state.ex | 10 +++++----- engine/lib/engine/search/subject.ex | 2 +- 107 files changed, 345 insertions(+), 345 deletions(-) diff --git a/engine/lib/engine.ex b/engine/lib/engine.ex index 392a8a93..ff7e8e3e 100644 --- a/engine/lib/engine.ex +++ b/engine/lib/engine.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl do +defmodule Engine do @moduledoc """ The remote control boots another elixir application in a separate VM, injects the remote control application into it and allows the language server to execute tasks in the @@ -6,11 +6,11 @@ defmodule Lexical.RemoteControl do """ alias Lexical.Project - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Api.Proxy - alias Lexical.RemoteControl.CodeAction - alias Lexical.RemoteControl.CodeIntelligence - alias Lexical.RemoteControl.ProjectNode + alias Engine + alias Engine.Api.Proxy + alias Engine.CodeAction + alias Engine.CodeIntelligence + alias Engine.ProjectNode require Logger diff --git a/engine/lib/engine/analyzer.ex b/engine/lib/engine/analyzer.ex index 872c8171..dd024353 100644 --- a/engine/lib/engine/analyzer.ex +++ b/engine/lib/engine/analyzer.ex @@ -1,13 +1,13 @@ -defmodule Lexical.RemoteControl.Analyzer do +defmodule Engine.Analyzer do alias Lexical.Ast alias Lexical.Ast.Analysis alias Lexical.Ast.Analysis.Require alias Lexical.Ast.Analysis.Use alias Lexical.Document.Position - alias Lexical.RemoteControl.Analyzer.Aliases - alias Lexical.RemoteControl.Analyzer.Imports - alias Lexical.RemoteControl.Analyzer.Requires - alias Lexical.RemoteControl.Analyzer.Uses + alias Engine.Analyzer.Aliases + alias Engine.Analyzer.Imports + alias Engine.Analyzer.Requires + alias Engine.Analyzer.Uses require Logger diff --git a/engine/lib/engine/analyzer/aliases.ex b/engine/lib/engine/analyzer/aliases.ex index 39987779..09b5d8c5 100644 --- a/engine/lib/engine/analyzer/aliases.ex +++ b/engine/lib/engine/analyzer/aliases.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Analyzer.Aliases do +defmodule Engine.Analyzer.Aliases do alias Lexical.Ast.Analysis alias Lexical.Ast.Analysis.Alias alias Lexical.Ast.Analysis.Scope diff --git a/engine/lib/engine/analyzer/imports.ex b/engine/lib/engine/analyzer/imports.ex index 77a1bb00..e2119aa7 100644 --- a/engine/lib/engine/analyzer/imports.ex +++ b/engine/lib/engine/analyzer/imports.ex @@ -1,12 +1,12 @@ -defmodule Lexical.RemoteControl.Analyzer.Imports do +defmodule Engine.Analyzer.Imports do alias Lexical.Ast.Analysis alias Lexical.Ast.Analysis.Import alias Lexical.Ast.Analysis.Scope alias Lexical.Document.Position alias Lexical.Document.Range alias Lexical.ProcessCache - alias Lexical.RemoteControl.Analyzer.Aliases - alias Lexical.RemoteControl.Module.Loader + alias Engine.Analyzer.Aliases + alias Engine.Module.Loader @spec at(Analysis.t(), Position.t()) :: [Scope.import_mfa()] def at(%Analysis{} = analysis, %Position{} = position) do diff --git a/engine/lib/engine/analyzer/requires.ex b/engine/lib/engine/analyzer/requires.ex index 2faebdf7..5bc38d20 100644 --- a/engine/lib/engine/analyzer/requires.ex +++ b/engine/lib/engine/analyzer/requires.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Analyzer.Requires do +defmodule Engine.Analyzer.Requires do alias Lexical.Ast.Analysis alias Lexical.Ast.Analysis.Require alias Lexical.Ast.Analysis.Scope diff --git a/engine/lib/engine/analyzer/uses.ex b/engine/lib/engine/analyzer/uses.ex index c0921e65..1268886a 100644 --- a/engine/lib/engine/analyzer/uses.ex +++ b/engine/lib/engine/analyzer/uses.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Analyzer.Uses do +defmodule Engine.Analyzer.Uses do alias Lexical.Ast.Analysis alias Lexical.Ast.Analysis.Scope alias Lexical.Document.Position diff --git a/engine/lib/engine/api.ex b/engine/lib/engine/api.ex index ffb72318..2b2caf9d 100644 --- a/engine/lib/engine/api.ex +++ b/engine/lib/engine/api.ex @@ -1,12 +1,12 @@ -defmodule Lexical.RemoteControl.Api do +defmodule Engine.Api do alias Lexical.Ast.Analysis alias Lexical.Ast.Env alias Lexical.Document alias Lexical.Document.Position alias Lexical.Document.Range alias Lexical.Project - alias Lexical.RemoteControl - alias Lexical.RemoteControl.CodeIntelligence + alias Engine + alias Engine.CodeIntelligence require Logger diff --git a/engine/lib/engine/api/messages.ex b/engine/lib/engine/api/messages.ex index fa1baaad..133b05a1 100644 --- a/engine/lib/engine/api/messages.ex +++ b/engine/lib/engine/api/messages.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Api.Messages do +defmodule Engine.Api.Messages do alias Lexical.Project import Record diff --git a/engine/lib/engine/api/proxy.ex b/engine/lib/engine/api/proxy.ex index 790af722..87474351 100644 --- a/engine/lib/engine/api/proxy.ex +++ b/engine/lib/engine/api/proxy.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Api.Proxy do +defmodule Engine.Api.Proxy do @moduledoc """ A bimodal buffering proxy @@ -32,14 +32,14 @@ defmodule Lexical.RemoteControl.Api.Proxy do alias Lexical.Document alias Lexical.Document.Changes - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Api.Messages - alias Lexical.RemoteControl.Api.Proxy.BufferingState - alias Lexical.RemoteControl.Api.Proxy.DrainingState - alias Lexical.RemoteControl.Api.Proxy.ProxyingState - alias Lexical.RemoteControl.Api.Proxy.Records - alias Lexical.RemoteControl.CodeMod - alias Lexical.RemoteControl.Commands + alias Engine + alias Engine.Api.Messages + alias Engine.Api.Proxy.BufferingState + alias Engine.Api.Proxy.DrainingState + alias Engine.Api.Proxy.ProxyingState + alias Engine.Api.Proxy.Records + alias Engine.CodeMod + alias Engine.Commands import Messages import Record diff --git a/engine/lib/engine/api/proxy/buffering_state.ex b/engine/lib/engine/api/proxy/buffering_state.ex index ea00e51e..fb2b683d 100644 --- a/engine/lib/engine/api/proxy/buffering_state.ex +++ b/engine/lib/engine/api/proxy/buffering_state.ex @@ -1,9 +1,9 @@ -defmodule Lexical.RemoteControl.Api.Proxy.BufferingState do +defmodule Engine.Api.Proxy.BufferingState do alias Lexical.Document - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Api - alias Lexical.RemoteControl.Build - alias Lexical.RemoteControl.Commands + alias Engine + alias Engine.Api + alias Engine.Build + alias Engine.Commands import Api.Messages import Api.Proxy.Records diff --git a/engine/lib/engine/api/proxy/draining_state.ex b/engine/lib/engine/api/proxy/draining_state.ex index 4941fc12..6c1b33ae 100644 --- a/engine/lib/engine/api/proxy/draining_state.ex +++ b/engine/lib/engine/api/proxy/draining_state.ex @@ -1,7 +1,7 @@ -defmodule Lexical.RemoteControl.Api.Proxy.DrainingState do - alias Lexical.RemoteControl.Api.Proxy.BufferingState - alias Lexical.RemoteControl.Api.Proxy.ProxyingState - alias Lexical.RemoteControl.Api.Proxy.Records +defmodule Engine.Api.Proxy.DrainingState do + alias Engine.Api.Proxy.BufferingState + alias Engine.Api.Proxy.ProxyingState + alias Engine.Api.Proxy.Records import Records diff --git a/engine/lib/engine/api/proxy/proxying_state.ex b/engine/lib/engine/api/proxy/proxying_state.ex index 81a723e4..466ac749 100644 --- a/engine/lib/engine/api/proxy/proxying_state.ex +++ b/engine/lib/engine/api/proxy/proxying_state.ex @@ -1,5 +1,5 @@ -defmodule Lexical.RemoteControl.Api.Proxy.ProxyingState do - alias Lexical.RemoteControl.Api.Proxy.Records +defmodule Engine.Api.Proxy.ProxyingState do + alias Engine.Api.Proxy.Records defstruct refs_to_from: %{} diff --git a/engine/lib/engine/api/proxy/records.ex b/engine/lib/engine/api/proxy/records.ex index 5f625b73..add2cf3f 100644 --- a/engine/lib/engine/api/proxy/records.ex +++ b/engine/lib/engine/api/proxy/records.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Api.Proxy.Records do +defmodule Engine.Api.Proxy.Records do alias Lexical.Formats import Record diff --git a/engine/lib/engine/application.ex b/engine/lib/engine/application.ex index 907fc43d..9133f657 100644 --- a/engine/lib/engine/application.ex +++ b/engine/lib/engine/application.ex @@ -1,7 +1,7 @@ -defmodule Lexical.RemoteControl.Application do +defmodule Engine.Application do @moduledoc false - alias Lexical.RemoteControl + alias Engine use Application require Logger @@ -31,7 +31,7 @@ defmodule Lexical.RemoteControl.Application do [] end - opts = [strategy: :one_for_one, name: Lexical.RemoteControl.Supervisor] + opts = [strategy: :one_for_one, name: Engine.Supervisor] Supervisor.start_link(children, opts) end end diff --git a/engine/lib/engine/bootstrap.ex b/engine/lib/engine/bootstrap.ex index d7c43b9a..e3ca756e 100644 --- a/engine/lib/engine/bootstrap.ex +++ b/engine/lib/engine/bootstrap.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Bootstrap do +defmodule Engine.Bootstrap do @moduledoc """ Bootstraps the remote control node boot sequence. @@ -7,7 +7,7 @@ defmodule Lexical.RemoteControl.Bootstrap do point, it's safe to start the project, as we should have all the code present to compile the system. """ alias Lexical.Project - alias Lexical.RemoteControl + alias Engine require Logger def init(%Project{} = project, document_store_entropy, app_configs) do diff --git a/engine/lib/engine/build.ex b/engine/lib/engine/build.ex index 0137a352..99f6d921 100644 --- a/engine/lib/engine/build.ex +++ b/engine/lib/engine/build.ex @@ -1,9 +1,9 @@ -defmodule Lexical.RemoteControl.Build do +defmodule Engine.Build do alias Lexical.Document alias Lexical.Project - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Build.Document.Compilers.HEEx - alias Lexical.RemoteControl.Build.State + alias Engine + alias Engine.Build.Document.Compilers.HEEx + alias Engine.Build.State alias Lexical.VM.Versions require Logger diff --git a/engine/lib/engine/build/capture_io.ex b/engine/lib/engine/build/capture_io.ex index 02e6b77a..9c571270 100644 --- a/engine/lib/engine/build/capture_io.ex +++ b/engine/lib/engine/build/capture_io.ex @@ -1,6 +1,6 @@ -defmodule Lexical.RemoteControl.Build.CaptureIO do +defmodule Engine.Build.CaptureIO do # Shamelessly stolen from ExUnit's CaptureIO - alias Lexical.RemoteControl.Build + alias Engine.Build def capture_io(fun) when is_function(fun, 0) do capture_io(:stdio, [], fun) diff --git a/engine/lib/engine/build/capture_server.ex b/engine/lib/engine/build/capture_server.ex index 8818a4d4..dabd9a62 100644 --- a/engine/lib/engine/build/capture_server.ex +++ b/engine/lib/engine/build/capture_server.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Build.CaptureServer do +defmodule Engine.Build.CaptureServer do @moduledoc false @compile {:no_warn_undefined, Logger} @timeout :infinity diff --git a/engine/lib/engine/build/document.ex b/engine/lib/engine/build/document.ex index d1e3a41f..cfeaec5d 100644 --- a/engine/lib/engine/build/document.ex +++ b/engine/lib/engine/build/document.ex @@ -1,8 +1,8 @@ -defmodule Lexical.RemoteControl.Build.Document do +defmodule Engine.Build.Document do alias Lexical.Document - alias Lexical.RemoteControl.Build - alias Lexical.RemoteControl.Build.Document.Compilers - alias Lexical.RemoteControl.Build.Isolation + alias Engine.Build + alias Engine.Build.Document.Compilers + alias Engine.Build.Isolation @compilers [Compilers.Config, Compilers.Elixir, Compilers.EEx, Compilers.HEEx, Compilers.NoOp] diff --git a/engine/lib/engine/build/document/compiler.ex b/engine/lib/engine/build/document/compiler.ex index 396d5dd8..955d6b25 100644 --- a/engine/lib/engine/build/document/compiler.ex +++ b/engine/lib/engine/build/document/compiler.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Build.Document.Compiler do +defmodule Engine.Build.Document.Compiler do @moduledoc """ A behaviour for document-level compilers """ diff --git a/engine/lib/engine/build/document/compilers/config.ex b/engine/lib/engine/build/document/compilers/config.ex index d135f580..da717b27 100644 --- a/engine/lib/engine/build/document/compilers/config.ex +++ b/engine/lib/engine/build/document/compilers/config.ex @@ -1,12 +1,12 @@ -defmodule Lexical.RemoteControl.Build.Document.Compilers.Config do +defmodule Engine.Build.Document.Compilers.Config do @moduledoc """ A compiler for elixir configuration """ alias Elixir.Features alias Lexical.Document alias Lexical.Plugin.V1.Diagnostic - alias Lexical.RemoteControl.Build - alias Lexical.RemoteControl.Build.Error.Location + alias Engine.Build + alias Engine.Build.Error.Location @elixir_source "Elixir" diff --git a/engine/lib/engine/build/document/compilers/eex.ex b/engine/lib/engine/build/document/compilers/eex.ex index 243ef224..c2ccfd90 100644 --- a/engine/lib/engine/build/document/compilers/eex.ex +++ b/engine/lib/engine/build/document/compilers/eex.ex @@ -1,12 +1,12 @@ -defmodule Lexical.RemoteControl.Build.Document.Compilers.EEx do +defmodule Engine.Build.Document.Compilers.EEx do @moduledoc """ A compiler for .eex files """ alias Lexical.Document alias Lexical.Plugin.V1.Diagnostic.Result - alias Lexical.RemoteControl.Build - alias Lexical.RemoteControl.Build.Document.Compiler - alias Lexical.RemoteControl.Build.Document.Compilers + alias Engine.Build + alias Engine.Build.Document.Compiler + alias Engine.Build.Document.Compilers @behaviour Compiler diff --git a/engine/lib/engine/build/document/compilers/elixir.ex b/engine/lib/engine/build/document/compilers/elixir.ex index e53ab498..244f20f1 100644 --- a/engine/lib/engine/build/document/compilers/elixir.ex +++ b/engine/lib/engine/build/document/compilers/elixir.ex @@ -1,12 +1,12 @@ -defmodule Lexical.RemoteControl.Build.Document.Compilers.Elixir do +defmodule Engine.Build.Document.Compilers.Elixir do @moduledoc """ A compiler for elixir source files (.ex and .exs) """ alias Elixir.Features alias Lexical.Document - alias Lexical.RemoteControl.Build - alias Lexical.RemoteControl.Build.Document.Compilers + alias Engine.Build + alias Engine.Build.Document.Compilers @behaviour Build.Document.Compiler diff --git a/engine/lib/engine/build/document/compilers/heex.ex b/engine/lib/engine/build/document/compilers/heex.ex index 69a0338b..caf5afda 100644 --- a/engine/lib/engine/build/document/compilers/heex.ex +++ b/engine/lib/engine/build/document/compilers/heex.ex @@ -1,11 +1,11 @@ -defmodule Lexical.RemoteControl.Build.Document.Compilers.HEEx do +defmodule Engine.Build.Document.Compilers.HEEx do @moduledoc """ A compiler for .heex files """ alias Lexical.Document alias Lexical.Plugin.V1.Diagnostic.Result - alias Lexical.RemoteControl.Build.Document.Compiler - alias Lexical.RemoteControl.Build.Document.Compilers + alias Engine.Build.Document.Compiler + alias Engine.Build.Document.Compilers require Logger @behaviour Compiler diff --git a/engine/lib/engine/build/document/compilers/no_op.ex b/engine/lib/engine/build/document/compilers/no_op.ex index c04bc91a..b4f7277a 100644 --- a/engine/lib/engine/build/document/compilers/no_op.ex +++ b/engine/lib/engine/build/document/compilers/no_op.ex @@ -1,8 +1,8 @@ -defmodule Lexical.RemoteControl.Build.Document.Compilers.NoOp do +defmodule Engine.Build.Document.Compilers.NoOp do @moduledoc """ A no-op, catch-all compiler. Always enabled, recognizes everything and returns no errors """ - alias Lexical.RemoteControl.Build.Document + alias Engine.Build.Document @behaviour Document.Compiler diff --git a/engine/lib/engine/build/document/compilers/quoted.ex b/engine/lib/engine/build/document/compilers/quoted.ex index 94551b50..f90a210d 100644 --- a/engine/lib/engine/build/document/compilers/quoted.ex +++ b/engine/lib/engine/build/document/compilers/quoted.ex @@ -1,11 +1,11 @@ -defmodule Lexical.RemoteControl.Build.Document.Compilers.Quoted do +defmodule Engine.Build.Document.Compilers.Quoted do alias Elixir.Features alias Lexical.Ast alias Lexical.Document - alias Lexical.RemoteControl.Build - alias Lexical.RemoteControl.ModuleMappings + alias Engine.Build + alias Engine.ModuleMappings - import Lexical.RemoteControl.Build.CaptureIO, only: [capture_io: 2] + import Engine.Build.CaptureIO, only: [capture_io: 2] def compile(%Document{} = document, quoted_ast, compiler_name) do prepare_compile(document.path) diff --git a/engine/lib/engine/build/error.ex b/engine/lib/engine/build/error.ex index f1ae13fe..67d980f8 100644 --- a/engine/lib/engine/build/error.ex +++ b/engine/lib/engine/build/error.ex @@ -1,8 +1,8 @@ -defmodule Lexical.RemoteControl.Build.Error do +defmodule Engine.Build.Error do alias Lexical.Ast alias Lexical.Document alias Lexical.Plugin.V1.Diagnostic.Result - alias Lexical.RemoteControl.Build.Error.Location + alias Engine.Build.Error.Location alias Mix.Task.Compiler require Logger diff --git a/engine/lib/engine/build/error/location.ex b/engine/lib/engine/build/error/location.ex index d8f4e92c..10211945 100644 --- a/engine/lib/engine/build/error/location.ex +++ b/engine/lib/engine/build/error/location.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Build.Error.Location do +defmodule Engine.Build.Error.Location do alias Lexical.Document alias Lexical.Document.Position alias Lexical.Document.Range diff --git a/engine/lib/engine/build/error/parse.ex b/engine/lib/engine/build/error/parse.ex index e0241601..9516c764 100644 --- a/engine/lib/engine/build/error/parse.ex +++ b/engine/lib/engine/build/error/parse.ex @@ -1,8 +1,8 @@ -defmodule Lexical.RemoteControl.Build.Error.Parse do +defmodule Engine.Build.Error.Parse do alias Lexical.Document alias Lexical.Document.Range alias Lexical.Plugin.V1.Diagnostic.Result - alias Lexical.RemoteControl.Build.Error.Location + alias Engine.Build.Error.Location @elixir_source "Elixir" diff --git a/engine/lib/engine/build/isolation.ex b/engine/lib/engine/build/isolation.ex index 4bfd3e00..7139fba1 100644 --- a/engine/lib/engine/build/isolation.ex +++ b/engine/lib/engine/build/isolation.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Build.Isolation do +defmodule Engine.Build.Isolation do @moduledoc """ Runs functions in an isolated, monitored process """ diff --git a/engine/lib/engine/build/project.ex b/engine/lib/engine/build/project.ex index f9f59f2c..022b4c46 100644 --- a/engine/lib/engine/build/project.ex +++ b/engine/lib/engine/build/project.ex @@ -1,9 +1,9 @@ -defmodule Lexical.RemoteControl.Build.Project do +defmodule Engine.Build.Project do alias Lexical.Project - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Build - alias Lexical.RemoteControl.Build.Isolation - alias Lexical.RemoteControl.Plugin + alias Engine + alias Engine.Build + alias Engine.Build.Isolation + alias Engine.Plugin alias Mix.Task.Compiler.Diagnostic use RemoteControl.Progress diff --git a/engine/lib/engine/build/state.ex b/engine/lib/engine/build/state.ex index baa7aa35..afc256ae 100644 --- a/engine/lib/engine/build/state.ex +++ b/engine/lib/engine/build/state.ex @@ -1,11 +1,11 @@ -defmodule Lexical.RemoteControl.Build.State do +defmodule Engine.Build.State do alias Elixir.Features alias Lexical.Document alias Lexical.Project - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Api.Messages - alias Lexical.RemoteControl.Build - alias Lexical.RemoteControl.Plugin + alias Engine + alias Engine.Api.Messages + alias Engine.Build + alias Engine.Plugin alias Lexical.VM.Versions require Logger diff --git a/engine/lib/engine/code_action.ex b/engine/lib/engine/code_action.ex index 4bbef10d..3d1f8e4a 100644 --- a/engine/lib/engine/code_action.ex +++ b/engine/lib/engine/code_action.ex @@ -1,9 +1,9 @@ -defmodule Lexical.RemoteControl.CodeAction do +defmodule Engine.CodeAction do alias Lexical.Document alias Lexical.Document.Changes alias Lexical.Document.Range - alias Lexical.RemoteControl.CodeAction.Diagnostic - alias Lexical.RemoteControl.CodeAction.Handlers + alias Engine.CodeAction.Diagnostic + alias Engine.CodeAction.Handlers defstruct [:title, :kind, :changes, :uri] diff --git a/engine/lib/engine/code_action/diagnostic.ex b/engine/lib/engine/code_action/diagnostic.ex index 78b6ee83..2e79a935 100644 --- a/engine/lib/engine/code_action/diagnostic.ex +++ b/engine/lib/engine/code_action/diagnostic.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.CodeAction.Diagnostic do +defmodule Engine.CodeAction.Diagnostic do alias Lexical.Document.Range defstruct [:range, :message, :source] diff --git a/engine/lib/engine/code_action/handler.ex b/engine/lib/engine/code_action/handler.ex index e02a61b4..8bf17f55 100644 --- a/engine/lib/engine/code_action/handler.ex +++ b/engine/lib/engine/code_action/handler.ex @@ -1,8 +1,8 @@ -defmodule Lexical.RemoteControl.CodeAction.Handler do +defmodule Engine.CodeAction.Handler do alias Lexical.Document alias Lexical.Document.Range - alias Lexical.RemoteControl.CodeAction - alias Lexical.RemoteControl.CodeAction.Diagnostic + alias Engine.CodeAction + alias Engine.CodeAction.Diagnostic @callback actions(Document.t(), Range.t(), [Diagnostic.t()]) :: [CodeAction.t()] @callback kinds() :: [CodeAction.code_action_kind()] diff --git a/engine/lib/engine/code_action/handlers/add_alias.ex b/engine/lib/engine/code_action/handlers/add_alias.ex index f3203cdc..6edc635b 100644 --- a/engine/lib/engine/code_action/handlers/add_alias.ex +++ b/engine/lib/engine/code_action/handlers/add_alias.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.CodeAction.Handlers.AddAlias do +defmodule Engine.CodeAction.Handlers.AddAlias do alias Lexical.Ast alias Lexical.Ast.Analysis alias Lexical.Ast.Analysis.Alias @@ -7,14 +7,14 @@ defmodule Lexical.RemoteControl.CodeAction.Handlers.AddAlias do alias Lexical.Document.Position alias Lexical.Document.Range alias Lexical.Formats - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Analyzer - alias Lexical.RemoteControl.CodeAction - alias Lexical.RemoteControl.CodeIntelligence.Entity - alias Lexical.RemoteControl.CodeMod - alias Lexical.RemoteControl.Modules - alias Lexical.RemoteControl.Search.Fuzzy - alias Lexical.RemoteControl.Search.Indexer.Entry + alias Engine + alias Engine.Analyzer + alias Engine.CodeAction + alias Engine.CodeIntelligence.Entity + alias Engine.CodeMod + alias Engine.Modules + alias Engine.Search.Fuzzy + alias Engine.Search.Indexer.Entry alias Mix.Tasks.Namespace alias Sourceror.Zipper diff --git a/engine/lib/engine/code_action/handlers/organize_aliases.ex b/engine/lib/engine/code_action/handlers/organize_aliases.ex index 01638ba1..c673b74d 100644 --- a/engine/lib/engine/code_action/handlers/organize_aliases.ex +++ b/engine/lib/engine/code_action/handlers/organize_aliases.ex @@ -1,11 +1,11 @@ -defmodule Lexical.RemoteControl.CodeAction.Handlers.OrganizeAliases do +defmodule Engine.CodeAction.Handlers.OrganizeAliases do alias Lexical.Ast.Analysis alias Lexical.Ast.Analysis.Scope alias Lexical.Document alias Lexical.Document.Changes alias Lexical.Document.Range - alias Lexical.RemoteControl.CodeAction - alias Lexical.RemoteControl.CodeMod + alias Engine.CodeAction + alias Engine.CodeMod require Logger diff --git a/engine/lib/engine/code_action/handlers/remove_unused_alias.ex b/engine/lib/engine/code_action/handlers/remove_unused_alias.ex index 2dfa432f..df1ea3b4 100644 --- a/engine/lib/engine/code_action/handlers/remove_unused_alias.ex +++ b/engine/lib/engine/code_action/handlers/remove_unused_alias.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.CodeAction.Handlers.RemoveUnusedAlias do +defmodule Engine.CodeAction.Handlers.RemoveUnusedAlias do @moduledoc """ A code action that removes an unused alias @@ -28,9 +28,9 @@ defmodule Lexical.RemoteControl.CodeAction.Handlers.RemoveUnusedAlias do alias Lexical.Document.Edit alias Lexical.Document.Position alias Lexical.Document.Range - alias Lexical.RemoteControl.Analyzer - alias Lexical.RemoteControl.CodeAction - alias Lexical.RemoteControl.CodeAction.Diagnostic + alias Engine.Analyzer + alias Engine.CodeAction + alias Engine.CodeAction.Diagnostic alias Sourceror.Zipper import Record diff --git a/engine/lib/engine/code_action/handlers/replace_remote_function.ex b/engine/lib/engine/code_action/handlers/replace_remote_function.ex index d7062bc5..7308a1b6 100644 --- a/engine/lib/engine/code_action/handlers/replace_remote_function.ex +++ b/engine/lib/engine/code_action/handlers/replace_remote_function.ex @@ -1,13 +1,13 @@ -defmodule Lexical.RemoteControl.CodeAction.Handlers.ReplaceRemoteFunction do +defmodule Engine.CodeAction.Handlers.ReplaceRemoteFunction do alias Lexical.Ast alias Lexical.Document alias Lexical.Document.Changes alias Lexical.Document.Edit alias Lexical.Document.Range - alias Lexical.RemoteControl - alias Lexical.RemoteControl.CodeAction - alias Lexical.RemoteControl.CodeAction.Diagnostic - alias Lexical.RemoteControl.Modules + alias Engine + alias Engine.CodeAction + alias Engine.CodeAction.Diagnostic + alias Engine.Modules alias Sourceror.Zipper @behaviour CodeAction.Handler diff --git a/engine/lib/engine/code_action/handlers/replace_with_underscore.ex b/engine/lib/engine/code_action/handlers/replace_with_underscore.ex index 620d0604..19da5de5 100644 --- a/engine/lib/engine/code_action/handlers/replace_with_underscore.ex +++ b/engine/lib/engine/code_action/handlers/replace_with_underscore.ex @@ -1,10 +1,10 @@ -defmodule Lexical.RemoteControl.CodeAction.Handlers.ReplaceWithUnderscore do +defmodule Engine.CodeAction.Handlers.ReplaceWithUnderscore do alias Lexical.Ast alias Lexical.Document alias Lexical.Document.Changes alias Lexical.Document.Range - alias Lexical.RemoteControl.CodeAction - alias Lexical.RemoteControl.CodeAction.Diagnostic + alias Engine.CodeAction + alias Engine.CodeAction.Diagnostic alias Sourceror.Zipper @behaviour CodeAction.Handler diff --git a/engine/lib/engine/code_intelligence/definition.ex b/engine/lib/engine/code_intelligence/definition.ex index b854f00b..9e5edfcf 100644 --- a/engine/lib/engine/code_intelligence/definition.ex +++ b/engine/lib/engine/code_intelligence/definition.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.CodeIntelligence.Definition do +defmodule Engine.CodeIntelligence.Definition do alias ElixirSense.Providers.Location, as: ElixirSenseLocation alias Future.Code alias Lexical.Ast @@ -7,9 +7,9 @@ defmodule Lexical.RemoteControl.CodeIntelligence.Definition do alias Lexical.Document.Location alias Lexical.Document.Position alias Lexical.Formats - alias Lexical.RemoteControl.CodeIntelligence.Entity - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Store + alias Engine.CodeIntelligence.Entity + alias Engine.Search.Indexer.Entry + alias Engine.Search.Store alias Lexical.Text require Logger diff --git a/engine/lib/engine/code_intelligence/docs.ex b/engine/lib/engine/code_intelligence/docs.ex index 5fa5da56..6fb9bad2 100644 --- a/engine/lib/engine/code_intelligence/docs.ex +++ b/engine/lib/engine/code_intelligence/docs.ex @@ -1,10 +1,10 @@ -defmodule Lexical.RemoteControl.CodeIntelligence.Docs do +defmodule Engine.CodeIntelligence.Docs do @moduledoc """ Utilities for fetching documentation for a compiled module. """ - alias Lexical.RemoteControl.CodeIntelligence.Docs.Entry - alias Lexical.RemoteControl.Modules + alias Engine.CodeIntelligence.Docs.Entry + alias Engine.Modules defstruct [:module, :doc, functions_and_macros: [], callbacks: [], types: []] diff --git a/engine/lib/engine/code_intelligence/docs/entry.ex b/engine/lib/engine/code_intelligence/docs/entry.ex index 098af162..359ae0f2 100644 --- a/engine/lib/engine/code_intelligence/docs/entry.ex +++ b/engine/lib/engine/code_intelligence/docs/entry.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.CodeIntelligence.Docs.Entry do +defmodule Engine.CodeIntelligence.Docs.Entry do @moduledoc """ A documentation entry for a named entity within a module. """ diff --git a/engine/lib/engine/code_intelligence/entity.ex b/engine/lib/engine/code_intelligence/entity.ex index 5f89024d..95bddc95 100644 --- a/engine/lib/engine/code_intelligence/entity.ex +++ b/engine/lib/engine/code_intelligence/entity.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.CodeIntelligence.Entity do +defmodule Engine.CodeIntelligence.Entity do alias Future.Code, as: Code alias Lexical.Ast alias Lexical.Ast.Analysis @@ -6,7 +6,7 @@ defmodule Lexical.RemoteControl.CodeIntelligence.Entity do alias Lexical.Document.Position alias Lexical.Document.Range alias Lexical.Formats - alias Lexical.RemoteControl + alias Engine alias Sourceror.Zipper require Logger diff --git a/engine/lib/engine/code_intelligence/references.ex b/engine/lib/engine/code_intelligence/references.ex index 878c6b37..0b1de7a5 100644 --- a/engine/lib/engine/code_intelligence/references.ex +++ b/engine/lib/engine/code_intelligence/references.ex @@ -1,14 +1,14 @@ -defmodule Lexical.RemoteControl.CodeIntelligence.References do +defmodule Engine.CodeIntelligence.References do alias Lexical.Ast.Analysis alias Lexical.Document alias Lexical.Document.Location alias Lexical.Document.Position - alias Lexical.RemoteControl.Analyzer - alias Lexical.RemoteControl.CodeIntelligence.Entity - alias Lexical.RemoteControl.CodeIntelligence.Variable - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Store - alias Lexical.RemoteControl.Search.Subject + alias Engine.Analyzer + alias Engine.CodeIntelligence.Entity + alias Engine.CodeIntelligence.Variable + alias Engine.Search.Indexer.Entry + alias Engine.Search.Store + alias Engine.Search.Subject require Logger diff --git a/engine/lib/engine/code_intelligence/structs.ex b/engine/lib/engine/code_intelligence/structs.ex index 8ef9e238..ea9018c3 100644 --- a/engine/lib/engine/code_intelligence/structs.ex +++ b/engine/lib/engine/code_intelligence/structs.ex @@ -1,8 +1,8 @@ -defmodule Lexical.RemoteControl.CodeIntelligence.Structs do - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Module.Loader - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Store +defmodule Engine.CodeIntelligence.Structs do + alias Engine + alias Engine.Module.Loader + alias Engine.Search.Indexer.Entry + alias Engine.Search.Store def for_project do if Mix.Project.get() do diff --git a/engine/lib/engine/code_intelligence/symbols.ex b/engine/lib/engine/code_intelligence/symbols.ex index 2459e43e..99822e50 100644 --- a/engine/lib/engine/code_intelligence/symbols.ex +++ b/engine/lib/engine/code_intelligence/symbols.ex @@ -1,11 +1,11 @@ -defmodule Lexical.RemoteControl.CodeIntelligence.Symbols do +defmodule Engine.CodeIntelligence.Symbols do alias Lexical.Document alias Lexical.Document.Range - alias Lexical.RemoteControl.CodeIntelligence.Symbols - alias Lexical.RemoteControl.Search - alias Lexical.RemoteControl.Search.Indexer - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Indexer.Extractors + alias Engine.CodeIntelligence.Symbols + alias Engine.Search + alias Engine.Search.Indexer + alias Engine.Search.Indexer.Entry + alias Engine.Search.Indexer.Extractors @block_types [ :ex_unit_describe, diff --git a/engine/lib/engine/code_intelligence/symbols/document.ex b/engine/lib/engine/code_intelligence/symbols/document.ex index 8009244e..0c02d7d1 100644 --- a/engine/lib/engine/code_intelligence/symbols/document.ex +++ b/engine/lib/engine/code_intelligence/symbols/document.ex @@ -1,7 +1,7 @@ -defmodule Lexical.RemoteControl.CodeIntelligence.Symbols.Document do +defmodule Engine.CodeIntelligence.Symbols.Document do alias Lexical.Document alias Lexical.Formats - alias Lexical.RemoteControl.Search.Indexer.Entry + alias Engine.Search.Indexer.Entry defstruct [:name, :type, :range, :detail_range, :detail, :original_type, :subject, children: []] diff --git a/engine/lib/engine/code_intelligence/symbols/workspace.ex b/engine/lib/engine/code_intelligence/symbols/workspace.ex index a78a6679..974c1fb2 100644 --- a/engine/lib/engine/code_intelligence/symbols/workspace.ex +++ b/engine/lib/engine/code_intelligence/symbols/workspace.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.CodeIntelligence.Symbols.Workspace do +defmodule Engine.CodeIntelligence.Symbols.Workspace do defmodule Link do defstruct [:uri, :range, :detail_range] @@ -15,7 +15,7 @@ defmodule Lexical.RemoteControl.CodeIntelligence.Symbols.Workspace do alias Lexical.Document alias Lexical.Formats - alias Lexical.RemoteControl.Search.Indexer.Entry + alias Engine.Search.Indexer.Entry defstruct [:name, :type, :link, container_name: nil] diff --git a/engine/lib/engine/code_intelligence/variable.ex b/engine/lib/engine/code_intelligence/variable.ex index 24168457..6a13ee47 100644 --- a/engine/lib/engine/code_intelligence/variable.ex +++ b/engine/lib/engine/code_intelligence/variable.ex @@ -1,9 +1,9 @@ -defmodule Lexical.RemoteControl.CodeIntelligence.Variable do +defmodule Engine.CodeIntelligence.Variable do alias Lexical.Ast.Analysis alias Lexical.Document.Position alias Lexical.Document.Range - alias Lexical.RemoteControl.Search.Indexer - alias Lexical.RemoteControl.Search.Indexer.Entry + alias Engine.Search.Indexer + alias Engine.Search.Indexer.Entry require Logger diff --git a/engine/lib/engine/code_mod/aliases.ex b/engine/lib/engine/code_mod/aliases.ex index 105aed95..0eefc338 100644 --- a/engine/lib/engine/code_mod/aliases.ex +++ b/engine/lib/engine/code_mod/aliases.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.CodeMod.Aliases do +defmodule Engine.CodeMod.Aliases do alias Lexical.Ast alias Lexical.Ast.Analysis alias Lexical.Ast.Analysis.Alias @@ -7,7 +7,7 @@ defmodule Lexical.RemoteControl.CodeMod.Aliases do alias Lexical.Document.Edit alias Lexical.Document.Position alias Lexical.Document.Range - alias Lexical.RemoteControl + alias Engine alias Sourceror.Zipper @doc """ diff --git a/engine/lib/engine/code_mod/diff.ex b/engine/lib/engine/code_mod/diff.ex index 85a4a338..628c7bf8 100644 --- a/engine/lib/engine/code_mod/diff.ex +++ b/engine/lib/engine/code_mod/diff.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.CodeMod.Diff do +defmodule Engine.CodeMod.Diff do alias Lexical.CodeUnit alias Lexical.Document alias Lexical.Document.Edit diff --git a/engine/lib/engine/code_mod/format.ex b/engine/lib/engine/code_mod/format.ex index 287ac5c3..eb03284d 100644 --- a/engine/lib/engine/code_mod/format.ex +++ b/engine/lib/engine/code_mod/format.ex @@ -1,10 +1,10 @@ -defmodule Lexical.RemoteControl.CodeMod.Format do +defmodule Engine.CodeMod.Format do alias Lexical.Document alias Lexical.Document.Changes alias Lexical.Project - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Build - alias Lexical.RemoteControl.CodeMod.Diff + alias Engine + alias Engine.Build + alias Engine.CodeMod.Diff require Logger diff --git a/engine/lib/engine/commands/reindex.ex b/engine/lib/engine/commands/reindex.ex index 610854b2..8634515c 100644 --- a/engine/lib/engine/commands/reindex.ex +++ b/engine/lib/engine/commands/reindex.ex @@ -1,10 +1,10 @@ -defmodule Lexical.RemoteControl.Commands.Reindex do +defmodule Engine.Commands.Reindex do defmodule State do alias Lexical.Ast.Analysis alias Lexical.Document alias Lexical.ProcessCache - alias Lexical.RemoteControl.Search - alias Lexical.RemoteControl.Search.Indexer + alias Engine.Search + alias Engine.Search.Indexer require Logger require ProcessCache @@ -72,9 +72,9 @@ defmodule Lexical.RemoteControl.Commands.Reindex do alias Lexical.Document alias Lexical.Project - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Api - alias Lexical.RemoteControl.Search + alias Engine + alias Engine.Api + alias Engine.Search use GenServer import Api.Messages diff --git a/engine/lib/engine/compilation/tracer.ex b/engine/lib/engine/compilation/tracer.ex index e779be3d..5296f3ab 100644 --- a/engine/lib/engine/compilation/tracer.ex +++ b/engine/lib/engine/compilation/tracer.ex @@ -1,7 +1,7 @@ -defmodule Lexical.RemoteControl.Compilation.Tracer do - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Build - alias Lexical.RemoteControl.Module.Loader +defmodule Engine.Compilation.Tracer do + alias Engine + alias Engine.Build + alias Engine.Module.Loader import RemoteControl.Api.Messages diff --git a/engine/lib/engine/completion.ex b/engine/lib/engine/completion.ex index 10923385..4b7b150d 100644 --- a/engine/lib/engine/completion.ex +++ b/engine/lib/engine/completion.ex @@ -1,11 +1,11 @@ -defmodule Lexical.RemoteControl.Completion do +defmodule Engine.Completion do alias Lexical.Ast.Analysis alias Lexical.Ast.Env alias Lexical.Document alias Lexical.Document.Position - alias Lexical.RemoteControl - alias Lexical.RemoteControl.CodeMod.Format - alias Lexical.RemoteControl.Completion.Candidate + alias Engine + alias Engine.CodeMod.Format + alias Engine.Completion.Candidate import Document.Line diff --git a/engine/lib/engine/completion/candidate.ex b/engine/lib/engine/completion/candidate.ex index 93125200..00a5199a 100644 --- a/engine/lib/engine/completion/candidate.ex +++ b/engine/lib/engine/completion/candidate.ex @@ -1,5 +1,5 @@ -defmodule Lexical.RemoteControl.Completion.Candidate do - alias Lexical.RemoteControl.Completion.Candidate.ArgumentNames +defmodule Engine.Completion.Candidate do + alias Engine.Completion.Candidate.ArgumentNames require Logger defmodule Function do diff --git a/engine/lib/engine/completion/candidate/argument_names.ex b/engine/lib/engine/completion/candidate/argument_names.ex index 6152f557..d8d2e1b8 100644 --- a/engine/lib/engine/completion/candidate/argument_names.ex +++ b/engine/lib/engine/completion/candidate/argument_names.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Completion.Candidate.ArgumentNames do +defmodule Engine.Completion.Candidate.ArgumentNames do @moduledoc """ Elixir sense, for whatever reason returns all the argument names when asked to do a completion on a function. This means that the arity of the function might differ from the argument names returned. Furthermore, the diff --git a/engine/lib/engine/dispatch.ex b/engine/lib/engine/dispatch.ex index 9cc3b3e8..e7bdc384 100644 --- a/engine/lib/engine/dispatch.ex +++ b/engine/lib/engine/dispatch.ex @@ -1,15 +1,15 @@ -defmodule Lexical.RemoteControl.Dispatch do +defmodule Engine.Dispatch do @moduledoc """ A global event dispatcher for lexical. Dispatch allows two recipients of its messages, processes and modules. A process must register itself via a call to `register_listener`, while a process must implement the - `Lexical.RemoteControl.Dispatch.Handler` behaviour and add the module to the @handlers module attribute. + `Engine.Dispatch.Handler` behaviour and add the module to the @handlers module attribute. """ - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Dispatch.Handlers - alias Lexical.RemoteControl.Dispatch.PubSub - import Lexical.RemoteControl.Api.Messages + alias Engine + alias Engine.Dispatch.Handlers + alias Engine.Dispatch.PubSub + import Engine.Api.Messages @handlers [PubSub, Handlers.Indexing] diff --git a/engine/lib/engine/dispatch/handler.ex b/engine/lib/engine/dispatch/handler.ex index 7675f780..47d4fcbc 100644 --- a/engine/lib/engine/dispatch/handler.ex +++ b/engine/lib/engine/dispatch/handler.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Dispatch.Handler do +defmodule Engine.Dispatch.Handler do @moduledoc """ Defines a handler that selectively receives events emitted from a remote control node. @@ -7,8 +7,8 @@ defmodule Lexical.RemoteControl.Dispatch.Handler do Define a handler, specifying the events to be handled and implementing `on_event/2`: defmodule MyHandler do - alias Lexical.RemoteControl.Api.Messages - alias Lexical.RemoteControl.Dispatch.Handler + alias Engine.Api.Messages + alias Engine.Dispatch.Handler import Messages @@ -23,7 +23,7 @@ defmodule Lexical.RemoteControl.Dispatch.Handler do Register the handler with dispatch: # The second argument here will be passed to the `init/1` callback - Lexical.RemoteControl.Dispatch.add_handler(MyHandler, init_arg) + Engine.Dispatch.add_handler(MyHandler, init_arg) """ @type event :: tuple() diff --git a/engine/lib/engine/dispatch/handlers/indexing.ex b/engine/lib/engine/dispatch/handlers/indexing.ex index f20ec4bd..933f9baf 100644 --- a/engine/lib/engine/dispatch/handlers/indexing.ex +++ b/engine/lib/engine/dispatch/handlers/indexing.ex @@ -1,9 +1,9 @@ -defmodule Lexical.RemoteControl.Dispatch.Handlers.Indexing do +defmodule Engine.Dispatch.Handlers.Indexing do alias Lexical.Document - alias Lexical.RemoteControl.Api.Messages - alias Lexical.RemoteControl.Commands - alias Lexical.RemoteControl.Dispatch - alias Lexical.RemoteControl.Search + alias Engine.Api.Messages + alias Engine.Commands + alias Engine.Dispatch + alias Engine.Search require Logger import Messages diff --git a/engine/lib/engine/dispatch/pub_sub.ex b/engine/lib/engine/dispatch/pub_sub.ex index 887cc46f..42df33ee 100644 --- a/engine/lib/engine/dispatch/pub_sub.ex +++ b/engine/lib/engine/dispatch/pub_sub.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Dispatch.PubSub do +defmodule Engine.Dispatch.PubSub do @moduledoc """ A pubsub event handler for a gen_event controller. """ diff --git a/engine/lib/engine/mix.ex b/engine/lib/engine/mix.ex index e64f5230..9536989b 100644 --- a/engine/lib/engine/mix.ex +++ b/engine/lib/engine/mix.ex @@ -1,6 +1,6 @@ -defmodule Lexical.RemoteControl.Mix do +defmodule Engine.Mix do alias Lexical.Project - alias Lexical.RemoteControl + alias Engine def in_project(fun) do if RemoteControl.project_node?() do diff --git a/engine/lib/engine/module/loader.ex b/engine/lib/engine/module/loader.ex index 149c3d06..b6fb1d59 100644 --- a/engine/lib/engine/module/loader.ex +++ b/engine/lib/engine/module/loader.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Module.Loader do +defmodule Engine.Module.Loader do @moduledoc """ Apparently, Code.ensure_loaded?/1 is pretty slow. I'm guessing because it has to do a round trip to the code server for each check. This in turn slows down indexing, so the thought diff --git a/engine/lib/engine/module_mappings.ex b/engine/lib/engine/module_mappings.ex index bcb8ce71..e56eeea6 100644 --- a/engine/lib/engine/module_mappings.ex +++ b/engine/lib/engine/module_mappings.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.ModuleMappings do +defmodule Engine.ModuleMappings do defmodule State do defstruct module_to_file: %{}, file_to_modules: %{} @@ -39,8 +39,8 @@ defmodule Lexical.RemoteControl.ModuleMappings do end end - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Api.Messages + alias Engine + alias Engine.Api.Messages use GenServer diff --git a/engine/lib/engine/modules.ex b/engine/lib/engine/modules.ex index 3b32e871..f278e026 100644 --- a/engine/lib/engine/modules.ex +++ b/engine/lib/engine/modules.ex @@ -1,10 +1,10 @@ -defmodule Lexical.RemoteControl.Modules do +defmodule Engine.Modules do @moduledoc """ Utilities for dealing with modules on the remote control node """ alias Future.Code.Typespec - alias Lexical.RemoteControl.Module.Loader + alias Engine.Module.Loader @typedoc "Module documentation record as defined by EEP-48" @type docs_v1 :: tuple() diff --git a/engine/lib/engine/plugin.ex b/engine/lib/engine/plugin.ex index f99fdba5..17167bdf 100644 --- a/engine/lib/engine/plugin.ex +++ b/engine/lib/engine/plugin.ex @@ -1,9 +1,9 @@ -defmodule Lexical.RemoteControl.Plugin do +defmodule Engine.Plugin do alias Lexical.Document alias Lexical.Project - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Api.Messages - alias Lexical.RemoteControl.Plugin.Runner + alias Engine + alias Engine.Api.Messages + alias Engine.Plugin.Runner import Messages diff --git a/engine/lib/engine/plugin/discovery.ex b/engine/lib/engine/plugin/discovery.ex index 4633218c..11e97ef6 100644 --- a/engine/lib/engine/plugin/discovery.ex +++ b/engine/lib/engine/plugin/discovery.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Plugin.Discovery do +defmodule Engine.Plugin.Discovery do @moduledoc """ Discovers any plugins in any loaded applications @@ -10,8 +10,8 @@ defmodule Lexical.RemoteControl.Plugin.Discovery do and the plugin will crash. """ - alias Lexical.RemoteControl.Module.Loader - alias Lexical.RemoteControl.Plugin.Runner + alias Engine.Module.Loader + alias Engine.Plugin.Runner alias Mix.Tasks.Namespace require Logger diff --git a/engine/lib/engine/plugin/runner.ex b/engine/lib/engine/plugin/runner.ex index 23af365d..ebeffb57 100644 --- a/engine/lib/engine/plugin/runner.ex +++ b/engine/lib/engine/plugin/runner.ex @@ -1,10 +1,10 @@ -defmodule Lexical.RemoteControl.Plugin.Runner do +defmodule Engine.Plugin.Runner do @moduledoc false alias Lexical.Document alias Lexical.Project - alias Lexical.RemoteControl.Module.Loader - alias Lexical.RemoteControl.Plugin.Runner + alias Engine.Module.Loader + alias Engine.Plugin.Runner require Logger diff --git a/engine/lib/engine/plugin/runner/coordinator.ex b/engine/lib/engine/plugin/runner/coordinator.ex index 0b99ba34..edd64aac 100644 --- a/engine/lib/engine/plugin/runner/coordinator.ex +++ b/engine/lib/engine/plugin/runner/coordinator.ex @@ -1,8 +1,8 @@ -defmodule Lexical.RemoteControl.Plugin.Runner.Coordinator do +defmodule Engine.Plugin.Runner.Coordinator do @moduledoc false alias Lexical.Formats - alias Lexical.RemoteControl.Plugin.Runner.Coordinator.State + alias Engine.Plugin.Runner.Coordinator.State require Logger use GenServer diff --git a/engine/lib/engine/plugin/runner/coordinator/state.ex b/engine/lib/engine/plugin/runner/coordinator/state.ex index a30a4617..a8289f12 100644 --- a/engine/lib/engine/plugin/runner/coordinator/state.ex +++ b/engine/lib/engine/plugin/runner/coordinator/state.ex @@ -1,7 +1,7 @@ -defmodule Lexical.RemoteControl.Plugin.Runner.Coordinator.State do +defmodule Engine.Plugin.Runner.Coordinator.State do @moduledoc false - alias Lexical.RemoteControl.Plugin.Runner + alias Engine.Plugin.Runner defstruct tasks: [], failures: %{} diff --git a/engine/lib/engine/plugin/supervisor.ex b/engine/lib/engine/plugin/supervisor.ex index ad950873..b6fbf6f3 100644 --- a/engine/lib/engine/plugin/supervisor.ex +++ b/engine/lib/engine/plugin/supervisor.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Plugin.Runner.Supervisor do +defmodule Engine.Plugin.Runner.Supervisor do @moduledoc false def child_spec(_) do diff --git a/engine/lib/engine/port.ex b/engine/lib/engine/port.ex index 05a210de..29e73ef9 100644 --- a/engine/lib/engine/port.ex +++ b/engine/lib/engine/port.ex @@ -1,10 +1,10 @@ -defmodule Lexical.RemoteControl.Port do +defmodule Engine.Port do @moduledoc """ Utilities for launching ports in the context of a project """ alias Lexical.Project - alias Lexical.RemoteControl + alias Engine @type open_opt :: {:env, list()} diff --git a/engine/lib/engine/progress.ex b/engine/lib/engine/progress.ex index 3448609c..0730dfce 100644 --- a/engine/lib/engine/progress.ex +++ b/engine/lib/engine/progress.ex @@ -1,7 +1,7 @@ -defmodule Lexical.RemoteControl.Progress do - alias Lexical.RemoteControl +defmodule Engine.Progress do + alias Engine - import Lexical.RemoteControl.Api.Messages + import Engine.Api.Messages @type label :: String.t() @type message :: String.t() diff --git a/engine/lib/engine/project_node.ex b/engine/lib/engine/project_node.ex index e79e288f..311b40a6 100644 --- a/engine/lib/engine/project_node.ex +++ b/engine/lib/engine/project_node.ex @@ -1,6 +1,6 @@ -defmodule Lexical.RemoteControl.ProjectNode do +defmodule Engine.ProjectNode do alias Lexical.Project - alias Lexical.RemoteControl + alias Engine require Logger defmodule State do @@ -105,7 +105,7 @@ defmodule Lexical.RemoteControl.ProjectNode do end alias Lexical.Document - alias Lexical.RemoteControl.ProjectNodeSupervisor + alias Engine.ProjectNodeSupervisor use GenServer def start(project, paths) do diff --git a/engine/lib/engine/project_node_supervisor.ex b/engine/lib/engine/project_node_supervisor.ex index f79cb9ae..b8a89098 100644 --- a/engine/lib/engine/project_node_supervisor.ex +++ b/engine/lib/engine/project_node_supervisor.ex @@ -1,6 +1,6 @@ -defmodule Lexical.RemoteControl.ProjectNodeSupervisor do +defmodule Engine.ProjectNodeSupervisor do alias Lexical.Project - alias Lexical.RemoteControl.ProjectNode + alias Engine.ProjectNode use DynamicSupervisor @dialyzer {:no_return, start_link: 1} diff --git a/engine/lib/engine/search/fuzzy.ex b/engine/lib/engine/search/fuzzy.ex index 43681828..d051dd22 100644 --- a/engine/lib/engine/search/fuzzy.ex +++ b/engine/lib/engine/search/fuzzy.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Search.Fuzzy do +defmodule Engine.Search.Fuzzy do @moduledoc """ A backend for fuzzy matching @@ -12,9 +12,9 @@ defmodule Lexical.RemoteControl.Search.Fuzzy do """ alias Lexical.Project - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Search.Fuzzy.Scorer - alias Lexical.RemoteControl.Search.Indexer.Entry + alias Engine + alias Engine.Search.Fuzzy.Scorer + alias Engine.Search.Indexer.Entry import Record defstruct subject_to_values: %{}, diff --git a/engine/lib/engine/search/fuzzy/scorer.ex b/engine/lib/engine/search/fuzzy/scorer.ex index 03b1903e..f5e31486 100644 --- a/engine/lib/engine/search/fuzzy/scorer.ex +++ b/engine/lib/engine/search/fuzzy/scorer.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Search.Fuzzy.Scorer do +defmodule Engine.Search.Fuzzy.Scorer do @moduledoc """ Scores a match based on heuristics. diff --git a/engine/lib/engine/search/indexer.ex b/engine/lib/engine/search/indexer.ex index c5dddaed..498fe6cf 100644 --- a/engine/lib/engine/search/indexer.ex +++ b/engine/lib/engine/search/indexer.ex @@ -1,11 +1,11 @@ -defmodule Lexical.RemoteControl.Search.Indexer do +defmodule Engine.Search.Indexer do alias Lexical.Identifier alias Lexical.ProcessCache alias Lexical.Project - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Progress - alias Lexical.RemoteControl.Search.Indexer - alias Lexical.RemoteControl.Search.Indexer.Entry + alias Engine + alias Engine.Progress + alias Engine.Search.Indexer + alias Engine.Search.Indexer.Entry require ProcessCache diff --git a/engine/lib/engine/search/indexer/entry.ex b/engine/lib/engine/search/indexer/entry.ex index cb17f9f0..91495127 100644 --- a/engine/lib/engine/search/indexer/entry.ex +++ b/engine/lib/engine/search/indexer/entry.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Entry do +defmodule Engine.Search.Indexer.Entry do @type function_type :: :public | :private | :delegated | :usage @type protocol_type :: :implementation | :definition @@ -51,7 +51,7 @@ defmodule Lexical.RemoteControl.Search.Indexer.Entry do @type date_type :: :calendar.datetime() | integer() | DateTime.t() alias Lexical.Identifier - alias Lexical.RemoteControl.Search.Indexer.Source.Block + alias Engine.Search.Indexer.Source.Block alias Lexical.StructAccess use StructAccess diff --git a/engine/lib/engine/search/indexer/extractors/ecto_schema.ex b/engine/lib/engine/search/indexer/extractors/ecto_schema.ex index fd7ff34b..a6c2f720 100644 --- a/engine/lib/engine/search/indexer/extractors/ecto_schema.ex +++ b/engine/lib/engine/search/indexer/extractors/ecto_schema.ex @@ -1,10 +1,10 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Extractors.EctoSchema do +defmodule Engine.Search.Indexer.Extractors.EctoSchema do alias Lexical.Ast alias Lexical.Document.Position - alias Lexical.RemoteControl.Analyzer - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Indexer.Metadata - alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + alias Engine.Analyzer + alias Engine.Search.Indexer.Entry + alias Engine.Search.Indexer.Metadata + alias Engine.Search.Indexer.Source.Reducer def extract( {:schema, meta, [{:__block__, _, [_source]} | _]} = schema_block, diff --git a/engine/lib/engine/search/indexer/extractors/ex_unit.ex b/engine/lib/engine/search/indexer/extractors/ex_unit.ex index d36f73ab..1639fabd 100644 --- a/engine/lib/engine/search/indexer/extractors/ex_unit.ex +++ b/engine/lib/engine/search/indexer/extractors/ex_unit.ex @@ -1,13 +1,13 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Extractors.ExUnit do +defmodule Engine.Search.Indexer.Extractors.ExUnit do alias Lexical.Ast alias Lexical.Ast.Analysis alias Lexical.Document.Position alias Lexical.Document.Range alias Lexical.Formats - alias Lexical.RemoteControl.Analyzer - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Indexer.Metadata - alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + alias Engine.Analyzer + alias Engine.Search.Indexer.Entry + alias Engine.Search.Indexer.Metadata + alias Engine.Search.Indexer.Source.Reducer require Logger diff --git a/engine/lib/engine/search/indexer/extractors/function_definition.ex b/engine/lib/engine/search/indexer/extractors/function_definition.ex index 39631474..fd746884 100644 --- a/engine/lib/engine/search/indexer/extractors/function_definition.ex +++ b/engine/lib/engine/search/indexer/extractors/function_definition.ex @@ -1,10 +1,10 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Extractors.FunctionDefinition do +defmodule Engine.Search.Indexer.Extractors.FunctionDefinition do alias Lexical.Ast alias Lexical.Ast.Analysis - alias Lexical.RemoteControl.Analyzer - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Indexer.Source.Reducer - alias Lexical.RemoteControl.Search.Subject + alias Engine.Analyzer + alias Engine.Search.Indexer.Entry + alias Engine.Search.Indexer.Source.Reducer + alias Engine.Search.Subject @function_definitions [:def, :defp] diff --git a/engine/lib/engine/search/indexer/extractors/function_reference.ex b/engine/lib/engine/search/indexer/extractors/function_reference.ex index aee640b2..80502a39 100644 --- a/engine/lib/engine/search/indexer/extractors/function_reference.ex +++ b/engine/lib/engine/search/indexer/extractors/function_reference.ex @@ -1,13 +1,13 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Extractors.FunctionReference do +defmodule Engine.Search.Indexer.Extractors.FunctionReference do alias Lexical.Ast alias Lexical.Document.Position alias Lexical.Document.Range - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Indexer.Extractors.FunctionDefinition - alias Lexical.RemoteControl.Search.Indexer.Metadata - alias Lexical.RemoteControl.Search.Indexer.Source.Reducer - alias Lexical.RemoteControl.Search.Subject + alias Engine + alias Engine.Search.Indexer.Entry + alias Engine.Search.Indexer.Extractors.FunctionDefinition + alias Engine.Search.Indexer.Metadata + alias Engine.Search.Indexer.Source.Reducer + alias Engine.Search.Subject require Logger diff --git a/engine/lib/engine/search/indexer/extractors/module.ex b/engine/lib/engine/search/indexer/extractors/module.ex index e010c3c3..3f9c7ee2 100644 --- a/engine/lib/engine/search/indexer/extractors/module.ex +++ b/engine/lib/engine/search/indexer/extractors/module.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Extractors.Module do +defmodule Engine.Search.Indexer.Extractors.Module do @moduledoc """ Extracts module references and definitions from AST """ @@ -7,12 +7,12 @@ defmodule Lexical.RemoteControl.Search.Indexer.Extractors.Module do alias Lexical.Document.Position alias Lexical.Document.Range alias Lexical.ProcessCache - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Indexer.Metadata - alias Lexical.RemoteControl.Search.Indexer.Source.Block - alias Lexical.RemoteControl.Search.Indexer.Source.Reducer - alias Lexical.RemoteControl.Search.Subject + alias Engine + alias Engine.Search.Indexer.Entry + alias Engine.Search.Indexer.Metadata + alias Engine.Search.Indexer.Source.Block + alias Engine.Search.Indexer.Source.Reducer + alias Engine.Search.Subject require Logger diff --git a/engine/lib/engine/search/indexer/extractors/module_attribute.ex b/engine/lib/engine/search/indexer/extractors/module_attribute.ex index f182e832..053a6531 100644 --- a/engine/lib/engine/search/indexer/extractors/module_attribute.ex +++ b/engine/lib/engine/search/indexer/extractors/module_attribute.ex @@ -1,14 +1,14 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Extractors.ModuleAttribute do +defmodule Engine.Search.Indexer.Extractors.ModuleAttribute do @moduledoc """ Extracts module attribute definitions and references from AST """ alias Lexical.Document.Position alias Lexical.Document.Range - alias Lexical.RemoteControl.Analyzer - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Indexer.Source.Reducer - alias Lexical.RemoteControl.Search.Subject + alias Engine.Analyzer + alias Engine.Search.Indexer.Entry + alias Engine.Search.Indexer.Source.Reducer + alias Engine.Search.Subject require Logger diff --git a/engine/lib/engine/search/indexer/extractors/struct_definition.ex b/engine/lib/engine/search/indexer/extractors/struct_definition.ex index b8663a30..0a63a190 100644 --- a/engine/lib/engine/search/indexer/extractors/struct_definition.ex +++ b/engine/lib/engine/search/indexer/extractors/struct_definition.ex @@ -1,8 +1,8 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Extractors.StructDefinition do +defmodule Engine.Search.Indexer.Extractors.StructDefinition do alias Lexical.Ast - alias Lexical.RemoteControl.Analyzer - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + alias Engine.Analyzer + alias Engine.Search.Indexer.Entry + alias Engine.Search.Indexer.Source.Reducer def extract({:defstruct, _, [_fields]} = definition, %Reducer{} = reducer) do document = reducer.analysis.document diff --git a/engine/lib/engine/search/indexer/extractors/struct_reference.ex b/engine/lib/engine/search/indexer/extractors/struct_reference.ex index 46b77018..718e6f7a 100644 --- a/engine/lib/engine/search/indexer/extractors/struct_reference.ex +++ b/engine/lib/engine/search/indexer/extractors/struct_reference.ex @@ -1,9 +1,9 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Extractors.StructReference do +defmodule Engine.Search.Indexer.Extractors.StructReference do alias Lexical.Ast - alias Lexical.RemoteControl.Analyzer - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Indexer.Source.Reducer - alias Lexical.RemoteControl.Search.Subject + alias Engine.Analyzer + alias Engine.Search.Indexer.Entry + alias Engine.Search.Indexer.Source.Reducer + alias Engine.Search.Subject require Logger diff --git a/engine/lib/engine/search/indexer/extractors/variable.ex b/engine/lib/engine/search/indexer/extractors/variable.ex index bd433aee..63867c47 100644 --- a/engine/lib/engine/search/indexer/extractors/variable.ex +++ b/engine/lib/engine/search/indexer/extractors/variable.ex @@ -1,8 +1,8 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Extractors.Variable do +defmodule Engine.Search.Indexer.Extractors.Variable do alias Lexical.Ast - alias Lexical.RemoteControl.Analyzer - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + alias Engine.Analyzer + alias Engine.Search.Indexer.Entry + alias Engine.Search.Indexer.Source.Reducer @defs [:def, :defmacro, :defp, :defmacrop] diff --git a/engine/lib/engine/search/indexer/metadata.ex b/engine/lib/engine/search/indexer/metadata.ex index e8453219..69dcc181 100644 --- a/engine/lib/engine/search/indexer/metadata.ex +++ b/engine/lib/engine/search/indexer/metadata.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Metadata do +defmodule Engine.Search.Indexer.Metadata do @moduledoc """ Utilities for extracting location information from AST metadata nodes. """ diff --git a/engine/lib/engine/search/indexer/module.ex b/engine/lib/engine/search/indexer/module.ex index 55632bf9..676728cf 100644 --- a/engine/lib/engine/search/indexer/module.ex +++ b/engine/lib/engine/search/indexer/module.ex @@ -1,5 +1,5 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Module do - alias Lexical.RemoteControl.Search.Indexer +defmodule Engine.Search.Indexer.Module do + alias Engine.Search.Indexer def index(module) do with true <- indexable?(module), diff --git a/engine/lib/engine/search/indexer/quoted.ex b/engine/lib/engine/search/indexer/quoted.ex index 18cac388..c0637ea9 100644 --- a/engine/lib/engine/search/indexer/quoted.ex +++ b/engine/lib/engine/search/indexer/quoted.ex @@ -1,7 +1,7 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Quoted do +defmodule Engine.Search.Indexer.Quoted do alias Lexical.Ast.Analysis alias Lexical.ProcessCache - alias Lexical.RemoteControl.Search.Indexer.Source.Reducer + alias Engine.Search.Indexer.Source.Reducer require ProcessCache diff --git a/engine/lib/engine/search/indexer/source.ex b/engine/lib/engine/search/indexer/source.ex index cd21c009..5c37e6c3 100644 --- a/engine/lib/engine/search/indexer/source.ex +++ b/engine/lib/engine/search/indexer/source.ex @@ -1,7 +1,7 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Source do +defmodule Engine.Search.Indexer.Source do alias Lexical.Ast alias Lexical.Document - alias Lexical.RemoteControl.Search.Indexer + alias Engine.Search.Indexer require Logger diff --git a/engine/lib/engine/search/indexer/source/block.ex b/engine/lib/engine/search/indexer/source/block.ex index 7cc5cd56..e6be318d 100644 --- a/engine/lib/engine/search/indexer/source/block.ex +++ b/engine/lib/engine/search/indexer/source/block.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Source.Block do +defmodule Engine.Search.Indexer.Source.Block do @moduledoc """ A struct that represents a block of source code """ diff --git a/engine/lib/engine/search/indexer/source/reducer.ex b/engine/lib/engine/search/indexer/source/reducer.ex index 9880f030..8b5280e0 100644 --- a/engine/lib/engine/search/indexer/source/reducer.ex +++ b/engine/lib/engine/search/indexer/source/reducer.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Search.Indexer.Source.Reducer do +defmodule Engine.Search.Indexer.Source.Reducer do @moduledoc """ A module and struct that can reduce over elixir AST via Macro.prewalk/3 @@ -8,10 +8,10 @@ defmodule Lexical.RemoteControl.Search.Indexer.Source.Reducer do alias Lexical.Ast.Analysis alias Lexical.Document.Position - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Indexer.Extractors - alias Lexical.RemoteControl.Search.Indexer.Metadata - alias Lexical.RemoteControl.Search.Indexer.Source.Block + alias Engine.Search.Indexer.Entry + alias Engine.Search.Indexer.Extractors + alias Engine.Search.Indexer.Metadata + alias Engine.Search.Indexer.Source.Block defstruct [:analysis, :entries, :position, :blocks, :block_hierarchy, extractors: []] diff --git a/engine/lib/engine/search/store.ex b/engine/lib/engine/search/store.ex index 0ad31fb2..9cbd5d25 100644 --- a/engine/lib/engine/search/store.ex +++ b/engine/lib/engine/search/store.ex @@ -1,14 +1,14 @@ -defmodule Lexical.RemoteControl.Search.Store do +defmodule Engine.Search.Store do @moduledoc """ A persistent store for search entries """ alias Lexical.Project - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Api - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Store - alias Lexical.RemoteControl.Search.Store.State + alias Engine + alias Engine.Api + alias Engine.Search.Indexer.Entry + alias Engine.Search.Store + alias Engine.Search.Store.State @type index_state :: :empty | :stale @type existing_entries :: [Entry.t()] @@ -108,7 +108,7 @@ defmodule Lexical.RemoteControl.Search.Store do end defp normalize_init_args([create_index, refresh_index]) do - normalize_init_args([Lexical.RemoteControl.get_project(), create_index, refresh_index]) + normalize_init_args([Engine.get_project(), create_index, refresh_index]) end defp normalize_init_args([%Project{} = project, create_index, refresh_index]) do diff --git a/engine/lib/engine/search/store/backend.ex b/engine/lib/engine/search/store/backend.ex index 042f4942..15963e7c 100644 --- a/engine/lib/engine/search/store/backend.ex +++ b/engine/lib/engine/search/store/backend.ex @@ -1,9 +1,9 @@ -defmodule Lexical.RemoteControl.Search.Store.Backend do +defmodule Engine.Search.Store.Backend do @moduledoc """ A behaviour for search store backends """ alias Lexical.Project - alias Lexical.RemoteControl.Search.Indexer.Entry + alias Engine.Search.Indexer.Entry @type version :: pos_integer() @type priv_state :: term() diff --git a/engine/lib/engine/search/store/backends/ets.ex b/engine/lib/engine/search/store/backends/ets.ex index 144fa2eb..eb17bd18 100644 --- a/engine/lib/engine/search/store/backends/ets.ex +++ b/engine/lib/engine/search/store/backends/ets.ex @@ -1,9 +1,9 @@ -defmodule Lexical.RemoteControl.Search.Store.Backends.Ets do +defmodule Engine.Search.Store.Backends.Ets do alias Lexical.Project - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Store.Backend - alias Lexical.RemoteControl.Search.Store.Backends.Ets.State + alias Engine + alias Engine.Search.Indexer.Entry + alias Engine.Search.Store.Backend + alias Engine.Search.Store.Backends.Ets.State use GenServer diff --git a/engine/lib/engine/search/store/backends/ets/schema.ex b/engine/lib/engine/search/store/backends/ets/schema.ex index 0c9e7ad7..bffee6bd 100644 --- a/engine/lib/engine/search/store/backends/ets/schema.ex +++ b/engine/lib/engine/search/store/backends/ets/schema.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Schema do +defmodule Engine.Search.Store.Backends.Ets.Schema do @moduledoc """ A use-able module that allows ETS schemas to be created and migrated. @@ -44,8 +44,8 @@ defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Schema do end alias Lexical.Project - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Store.Backends.Ets.Wal + alias Engine.Search.Indexer.Entry + alias Engine.Search.Store.Backends.Ets.Wal import Wal, only: :macros diff --git a/engine/lib/engine/search/store/backends/ets/schemas/legacy_v0.ex b/engine/lib/engine/search/store/backends/ets/schemas/legacy_v0.ex index 57253244..65c1155d 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/legacy_v0.ex +++ b/engine/lib/engine/search/store/backends/ets/schemas/legacy_v0.ex @@ -1,11 +1,11 @@ -defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Schemas.LegacyV0 do +defmodule Engine.Search.Store.Backends.Ets.Schemas.LegacyV0 do @moduledoc """ A legacy version of the schema. We pushed the initial indexer to main before we added schemas and versioning. This represents that schema type, hence the non-versioned name. """ - alias Lexical.RemoteControl.Search.Store.Backends.Ets.Schema + alias Engine.Search.Store.Backends.Ets.Schema use Schema, version: 0 diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v1.ex b/engine/lib/engine/search/store/backends/ets/schemas/v1.ex index 5653a3ec..502f81d9 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/v1.ex +++ b/engine/lib/engine/search/store/backends/ets/schemas/v1.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Schemas.V1 do +defmodule Engine.Search.Store.Backends.Ets.Schemas.V1 do @moduledoc """ This schema uses a bit of data duplication in order to achieve good performance. @@ -9,8 +9,8 @@ defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Schemas.V1 do """ - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Store.Backends.Ets.Schema + alias Engine.Search.Indexer.Entry + alias Engine.Search.Store.Backends.Ets.Schema use Schema, version: 1 diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v2.ex b/engine/lib/engine/search/store/backends/ets/schemas/v2.ex index ce326b65..13fec328 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/v2.ex +++ b/engine/lib/engine/search/store/backends/ets/schemas/v2.ex @@ -1,6 +1,6 @@ -defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Schemas.V2 do - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Store.Backends.Ets.Schema +defmodule Engine.Search.Store.Backends.Ets.Schemas.V2 do + alias Engine.Search.Indexer.Entry + alias Engine.Search.Store.Backends.Ets.Schema require Entry use Schema, version: 2 diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v3.ex b/engine/lib/engine/search/store/backends/ets/schemas/v3.ex index 98c36f77..19713ca2 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/v3.ex +++ b/engine/lib/engine/search/store/backends/ets/schemas/v3.ex @@ -1,6 +1,6 @@ -defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Schemas.V3 do - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Store.Backends.Ets.Schema +defmodule Engine.Search.Store.Backends.Ets.Schemas.V3 do + alias Engine.Search.Indexer.Entry + alias Engine.Search.Store.Backends.Ets.Schema require Entry use Schema, version: 3 diff --git a/engine/lib/engine/search/store/backends/ets/state.ex b/engine/lib/engine/search/store/backends/ets/state.ex index 08891fa3..6551b4ed 100644 --- a/engine/lib/engine/search/store/backends/ets/state.ex +++ b/engine/lib/engine/search/store/backends/ets/state.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.State do +defmodule Engine.Search.Store.Backends.Ets.State do @moduledoc """ An ETS based search backend @@ -6,10 +6,10 @@ defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.State do """ alias Lexical.Project - alias Lexical.RemoteControl.Search.Indexer.Entry - alias Lexical.RemoteControl.Search.Store.Backends.Ets.Schema - alias Lexical.RemoteControl.Search.Store.Backends.Ets.Schemas - alias Lexical.RemoteControl.Search.Store.Backends.Ets.Wal + alias Engine.Search.Indexer.Entry + alias Engine.Search.Store.Backends.Ets.Schema + alias Engine.Search.Store.Backends.Ets.Schemas + alias Engine.Search.Store.Backends.Ets.Wal @schema_order [ Schemas.LegacyV0, diff --git a/engine/lib/engine/search/store/backends/ets/wal.ex b/engine/lib/engine/search/store/backends/ets/wal.ex index ef092838..1786534d 100644 --- a/engine/lib/engine/search/store/backends/ets/wal.ex +++ b/engine/lib/engine/search/store/backends/ets/wal.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Search.Store.Backends.Ets.Wal do +defmodule Engine.Search.Store.Backends.Ets.Wal do @moduledoc """ A (hopefully) simple write-ahead log """ diff --git a/engine/lib/engine/search/store/state.ex b/engine/lib/engine/search/store/state.ex index 9742282f..4df8f30d 100644 --- a/engine/lib/engine/search/store/state.ex +++ b/engine/lib/engine/search/store/state.ex @@ -1,9 +1,9 @@ -defmodule Lexical.RemoteControl.Search.Store.State do +defmodule Engine.Search.Store.State do alias Lexical.Project - alias Lexical.RemoteControl.Api.Messages - alias Lexical.RemoteControl.Dispatch - alias Lexical.RemoteControl.Search.Fuzzy - alias Lexical.RemoteControl.Search.Indexer.Entry + alias Engine.Api.Messages + alias Engine.Dispatch + alias Engine.Search.Fuzzy + alias Engine.Search.Indexer.Entry require Logger import Messages diff --git a/engine/lib/engine/search/subject.ex b/engine/lib/engine/search/subject.ex index 1e701042..33f05f4b 100644 --- a/engine/lib/engine/search/subject.ex +++ b/engine/lib/engine/search/subject.ex @@ -1,4 +1,4 @@ -defmodule Lexical.RemoteControl.Search.Subject do +defmodule Engine.Search.Subject do @moduledoc """ Functions for converting to a search entry's subject field """ From 43f5355eccc1bc7e929a44b427d53b1439c97df4 Mon Sep 17 00:00:00 2001 From: Mitchell Hanberg Date: Wed, 1 Jan 2025 12:03:11 -0500 Subject: [PATCH 03/12] wip: replace remaining RemoteControl aliases with Engine --- engine/lib/engine.ex | 12 +++--- engine/lib/engine/api.ex | 42 +++++++++---------- engine/lib/engine/api/proxy.ex | 12 +++--- .../lib/engine/api/proxy/buffering_state.ex | 2 +- engine/lib/engine/application.ex | 28 ++++++------- engine/lib/engine/bootstrap.ex | 4 +- engine/lib/engine/build.ex | 4 +- engine/lib/engine/build/project.ex | 4 +- engine/lib/engine/build/state.ex | 20 ++++----- .../engine/code_action/handlers/add_alias.ex | 2 +- .../handlers/replace_remote_function.ex | 2 +- engine/lib/engine/code_intelligence/entity.ex | 18 ++++---- .../lib/engine/code_intelligence/structs.ex | 2 +- engine/lib/engine/code_mod/aliases.ex | 2 +- engine/lib/engine/code_mod/format.ex | 6 +-- engine/lib/engine/commands/reindex.ex | 6 +-- engine/lib/engine/compilation/tracer.ex | 8 ++-- engine/lib/engine/completion.ex | 2 +- engine/lib/engine/dispatch.ex | 4 +- engine/lib/engine/mix.ex | 8 ++-- engine/lib/engine/module_mappings.ex | 2 +- engine/lib/engine/plugin.ex | 4 +- engine/lib/engine/port.ex | 4 +- engine/lib/engine/progress.ex | 10 ++--- engine/lib/engine/project_node.ex | 4 +- engine/lib/engine/search/fuzzy.ex | 4 +- engine/lib/engine/search/indexer.ex | 4 +- .../indexer/extractors/function_reference.ex | 6 +-- .../search/indexer/extractors/module.ex | 4 +- engine/lib/engine/search/store.ex | 2 +- .../lib/engine/search/store/backends/ets.ex | 6 +-- 31 files changed, 119 insertions(+), 119 deletions(-) diff --git a/engine/lib/engine.ex b/engine/lib/engine.ex index ff7e8e3e..aaca3f2e 100644 --- a/engine/lib/engine.ex +++ b/engine/lib/engine.ex @@ -29,16 +29,16 @@ defmodule Engine do defdelegate broadcast(message), to: Proxy - defdelegate expand_alias(segments_or_module, analysis, position), to: RemoteControl.Analyzer + defdelegate expand_alias(segments_or_module, analysis, position), to: Engine.Analyzer defdelegate list_modules, to: :code, as: :all_available defdelegate code_actions(document, range, diagnostics, kinds), to: CodeAction, as: :for_range - defdelegate complete(env), to: RemoteControl.Completion, as: :elixir_sense_expand + defdelegate complete(env), to: Engine.Completion, as: :elixir_sense_expand defdelegate complete_struct_fields(analysis, position), - to: RemoteControl.Completion, + to: Engine.Completion, as: :struct_fields defdelegate definition(document, position), to: CodeIntelligence.Definition @@ -46,13 +46,13 @@ defmodule Engine do defdelegate references(analysis, position, include_definitions?), to: CodeIntelligence.References - defdelegate modules_with_prefix(prefix), to: RemoteControl.Modules, as: :with_prefix + defdelegate modules_with_prefix(prefix), to: Engine.Modules, as: :with_prefix - defdelegate modules_with_prefix(prefix, predicate), to: RemoteControl.Modules, as: :with_prefix + defdelegate modules_with_prefix(prefix, predicate), to: Engine.Modules, as: :with_prefix defdelegate docs(module, opts \\ []), to: CodeIntelligence.Docs, as: :for_module - defdelegate register_listener(listener_pid, message_types), to: RemoteControl.Dispatch + defdelegate register_listener(listener_pid, message_types), to: Engine.Dispatch defdelegate resolve_entity(analysis, position), to: CodeIntelligence.Entity, as: :resolve diff --git a/engine/lib/engine/api.ex b/engine/lib/engine/api.ex index 2b2caf9d..28ccca39 100644 --- a/engine/lib/engine/api.ex +++ b/engine/lib/engine/api.ex @@ -11,11 +11,11 @@ defmodule Engine.Api do require Logger def schedule_compile(%Project{} = project, force?) do - RemoteControl.call(project, RemoteControl, :schedule_compile, [force?]) + Engine.call(project, Engine, :schedule_compile, [force?]) end def compile_document(%Project{} = project, %Document{} = document) do - RemoteControl.call(project, RemoteControl, :compile_document, [document]) + Engine.call(project, Engine, :compile_document, [document]) end def expand_alias( @@ -24,7 +24,7 @@ defmodule Engine.Api do %Analysis{} = analysis, %Position{} = position ) do - RemoteControl.call(project, RemoteControl, :expand_alias, [ + Engine.call(project, Engine, :expand_alias, [ segments_or_module, analysis, position @@ -32,11 +32,11 @@ defmodule Engine.Api do end def list_modules(%Project{} = project) do - RemoteControl.call(project, RemoteControl, :list_modules) + Engine.call(project, Engine, :list_modules) end def format(%Project{} = project, %Document{} = document) do - RemoteControl.call(project, RemoteControl, :format, [document]) + Engine.call(project, Engine, :format, [document]) end def code_actions( @@ -46,7 +46,7 @@ defmodule Engine.Api do diagnostics, kinds ) do - RemoteControl.call(project, RemoteControl, :code_actions, [ + Engine.call(project, Engine, :code_actions, [ document, range, diagnostics, @@ -56,18 +56,18 @@ defmodule Engine.Api do def complete(%Project{} = project, %Env{} = env) do Logger.info("Completion for #{inspect(env.position)}") - RemoteControl.call(project, RemoteControl, :complete, [env]) + Engine.call(project, Engine, :complete, [env]) end def complete_struct_fields(%Project{} = project, %Analysis{} = analysis, %Position{} = position) do - RemoteControl.call(project, RemoteControl, :complete_struct_fields, [ + Engine.call(project, Engine, :complete_struct_fields, [ analysis, position ]) end def definition(%Project{} = project, %Document{} = document, %Position{} = position) do - RemoteControl.call(project, RemoteControl, :definition, [document, position]) + Engine.call(project, Engine, :definition, [document, position]) end def references( @@ -76,7 +76,7 @@ defmodule Engine.Api do %Position{} = position, include_definitions? ) do - RemoteControl.call(project, RemoteControl, :references, [ + Engine.call(project, Engine, :references, [ analysis, position, include_definitions? @@ -85,52 +85,52 @@ defmodule Engine.Api do def modules_with_prefix(%Project{} = project, prefix) when is_binary(prefix) or is_atom(prefix) do - RemoteControl.call(project, RemoteControl, :modules_with_prefix, [prefix]) + Engine.call(project, Engine, :modules_with_prefix, [prefix]) end def modules_with_prefix(%Project{} = project, prefix, predicate) when is_binary(prefix) or is_atom(prefix) do - RemoteControl.call(project, RemoteControl, :modules_with_prefix, [prefix, predicate]) + Engine.call(project, Engine, :modules_with_prefix, [prefix, predicate]) end @spec docs(Project.t(), module()) :: {:ok, CodeIntelligence.Docs.t()} | {:error, any()} def docs(%Project{} = project, module, opts \\ []) when is_atom(module) do - RemoteControl.call(project, RemoteControl, :docs, [module, opts]) + Engine.call(project, Engine, :docs, [module, opts]) end def register_listener(%Project{} = project, listener_pid, message_types) when is_pid(listener_pid) and is_list(message_types) do - RemoteControl.call(project, RemoteControl, :register_listener, [ + Engine.call(project, Engine, :register_listener, [ listener_pid, message_types ]) end def broadcast(%Project{} = project, message) do - RemoteControl.call(project, RemoteControl, :broadcast, [message]) + Engine.call(project, Engine, :broadcast, [message]) end def reindex(%Project{} = project) do - RemoteControl.call(project, RemoteControl, :reindex, []) + Engine.call(project, Engine, :reindex, []) end def index_running?(%Project{} = project) do - RemoteControl.call(project, RemoteControl, :index_running?, []) + Engine.call(project, Engine, :index_running?, []) end def resolve_entity(%Project{} = project, %Analysis{} = analysis, %Position{} = position) do - RemoteControl.call(project, RemoteControl, :resolve_entity, [analysis, position]) + Engine.call(project, Engine, :resolve_entity, [analysis, position]) end def struct_definitions(%Project{} = project) do - RemoteControl.call(project, RemoteControl, :struct_definitions, []) + Engine.call(project, Engine, :struct_definitions, []) end def document_symbols(%Project{} = project, %Document{} = document) do - RemoteControl.call(project, RemoteControl, :document_symbols, [document]) + Engine.call(project, Engine, :document_symbols, [document]) end def workspace_symbols(%Project{} = project, query) do - RemoteControl.call(project, RemoteControl, :workspace_symbols, [query]) + Engine.call(project, Engine, :workspace_symbols, [query]) end end diff --git a/engine/lib/engine/api/proxy.ex b/engine/lib/engine/api/proxy.ex index 87474351..bbe847a3 100644 --- a/engine/lib/engine/api/proxy.ex +++ b/engine/lib/engine/api/proxy.ex @@ -63,25 +63,25 @@ defmodule Engine.Api.Proxy do # proxied functions def broadcast(percent_progress() = message) do - RemoteControl.Dispatch.broadcast(message) + Engine.Dispatch.broadcast(message) end def broadcast(message) do - mfa = to_mfa(RemoteControl.Dispatch.broadcast(message)) + mfa = to_mfa(Engine.Dispatch.broadcast(message)) :gen_statem.call(__MODULE__, buffer(contents: mfa)) end def schedule_compile(force? \\ false) do - project = RemoteControl.get_project() + project = Engine.get_project() - mfa = to_mfa(RemoteControl.Build.schedule_compile(project, force?)) + mfa = to_mfa(Engine.Build.schedule_compile(project, force?)) :gen_statem.call(__MODULE__, buffer(contents: mfa)) end def compile_document(document) do - project = RemoteControl.get_project() + project = Engine.get_project() - mfa = to_mfa(RemoteControl.Build.compile_document(project, document)) + mfa = to_mfa(Engine.Build.compile_document(project, document)) :gen_statem.call(__MODULE__, buffer(contents: mfa)) end diff --git a/engine/lib/engine/api/proxy/buffering_state.ex b/engine/lib/engine/api/proxy/buffering_state.ex index fb2b683d..be1522d2 100644 --- a/engine/lib/engine/api/proxy/buffering_state.ex +++ b/engine/lib/engine/api/proxy/buffering_state.ex @@ -23,7 +23,7 @@ defmodule Engine.Api.Proxy.BufferingState do state.buffer |> Enum.reverse() |> Enum.split_with(fn value -> - match?(mfa(module: RemoteControl.Dispatch, function: :broadcast), value) + match?(mfa(module: Engine.Dispatch, function: :broadcast), value) end) {project_compile, document_compiles, reindex} = collapse_commands(commands) diff --git a/engine/lib/engine/application.ex b/engine/lib/engine/application.ex index 9133f657..0ae2dc47 100644 --- a/engine/lib/engine/application.ex +++ b/engine/lib/engine/application.ex @@ -9,22 +9,22 @@ defmodule Engine.Application do @impl true def start(_type, _args) do children = - if RemoteControl.project_node?() do + if Engine.project_node?() do [ - RemoteControl.Api.Proxy, - RemoteControl.Commands.Reindex, - RemoteControl.Module.Loader, - {RemoteControl.Dispatch, progress: true}, - RemoteControl.ModuleMappings, - RemoteControl.Build, - RemoteControl.Build.CaptureServer, - RemoteControl.Plugin.Runner.Supervisor, - RemoteControl.Plugin.Runner.Coordinator, - RemoteControl.Search.Store.Backends.Ets, - {RemoteControl.Search.Store, + Engine.Api.Proxy, + Engine.Commands.Reindex, + Engine.Module.Loader, + {Engine.Dispatch, progress: true}, + Engine.ModuleMappings, + Engine.Build, + Engine.Build.CaptureServer, + Engine.Plugin.Runner.Supervisor, + Engine.Plugin.Runner.Coordinator, + Engine.Search.Store.Backends.Ets, + {Engine.Search.Store, [ - &RemoteControl.Search.Indexer.create_index/1, - &RemoteControl.Search.Indexer.update_index/2 + &Engine.Search.Indexer.create_index/1, + &Engine.Search.Indexer.update_index/2 ]} ] else diff --git a/engine/lib/engine/bootstrap.ex b/engine/lib/engine/bootstrap.ex index e3ca756e..053971fd 100644 --- a/engine/lib/engine/bootstrap.ex +++ b/engine/lib/engine/bootstrap.ex @@ -24,7 +24,7 @@ defmodule Engine.Bootstrap do {:ok, _} <- Application.ensure_all_started(:mix), {:ok, _} <- Application.ensure_all_started(:logger) do project = maybe_load_mix_exs(project) - RemoteControl.set_project(project) + Engine.set_project(project) Mix.env(:test) ExUnit.start() start_logger(project) @@ -76,7 +76,7 @@ defmodule Engine.Bootstrap do # app is an umbrella (umbrealla? returns false when started in a subapp) # to no avail. This was the only thing that consistently worked {:ok, configured_root} = - RemoteControl.Mix.in_project(project, fn _ -> + Engine.Mix.in_project(project, fn _ -> Mix.Project.config() |> Keyword.get(:config_path) |> Path.dirname() diff --git a/engine/lib/engine/build.ex b/engine/lib/engine/build.ex index 99f6d921..e52413d9 100644 --- a/engine/lib/engine/build.ex +++ b/engine/lib/engine/build.ex @@ -46,7 +46,7 @@ defmodule Engine.Build do end def with_lock(func) do - RemoteControl.with_lock(__MODULE__, func) + Engine.with_lock(__MODULE__, func) end # GenServer Callbacks @@ -57,7 +57,7 @@ defmodule Engine.Build do @impl GenServer def init([]) do - state = State.new(RemoteControl.get_project()) + state = State.new(Engine.get_project()) with :ok <- State.set_compiler_options() do {:ok, state, {:continue, :ensure_build_directory}} diff --git a/engine/lib/engine/build/project.ex b/engine/lib/engine/build/project.ex index 022b4c46..0263f474 100644 --- a/engine/lib/engine/build/project.ex +++ b/engine/lib/engine/build/project.ex @@ -6,11 +6,11 @@ defmodule Engine.Build.Project do alias Engine.Plugin alias Mix.Task.Compiler.Diagnostic - use RemoteControl.Progress + use Engine.Progress require Logger def compile(%Project{} = project, initial?) do - RemoteControl.Mix.in_project(fn _ -> + Engine.Mix.in_project(fn _ -> Mix.Task.clear() prepare_for_project_build(initial?) diff --git a/engine/lib/engine/build/state.ex b/engine/lib/engine/build/state.ex index afc256ae..208aca72 100644 --- a/engine/lib/engine/build/state.ex +++ b/engine/lib/engine/build/state.ex @@ -12,7 +12,7 @@ defmodule Engine.Build.State do import Messages - use RemoteControl.Progress + use Engine.Progress defstruct project: nil, build_number: 0, @@ -61,7 +61,7 @@ defmodule Engine.Build.State do # If the project directory isn't there, for some reason the main build fails, so we create it here # to ensure that the build will succeed. project = state.project - build_path = RemoteControl.Build.path(project) + build_path = Engine.Build.path(project) unless Versions.compatible?(build_path) do Logger.info("Build path #{build_path} was compiled on a previous erlang version. Deleting") @@ -87,7 +87,7 @@ defmodule Engine.Build.State do compile_requested_message = project_compile_requested(project: project, build_number: state.build_number) - RemoteControl.broadcast(compile_requested_message) + Engine.broadcast(compile_requested_message) {elapsed_us, result} = :timer.tc(fn -> Build.Project.compile(project, initial?) end) elapsed_ms = to_ms(elapsed_us) @@ -116,8 +116,8 @@ defmodule Engine.Build.State do diagnostics: diagnostics ) - RemoteControl.broadcast(compile_message) - RemoteControl.broadcast(diagnostics_message) + Engine.broadcast(compile_message) + Engine.broadcast(diagnostics_message) Plugin.diagnose(project, state.build_number) end) @@ -129,10 +129,10 @@ defmodule Engine.Build.State do project = state.project Build.with_lock(fn -> - RemoteControl.broadcast(file_compile_requested(uri: document.uri)) + Engine.broadcast(file_compile_requested(uri: document.uri)) safe_compile_func = fn -> - RemoteControl.Mix.in_project(fn _ -> Build.Document.compile(document) end) + Engine.Mix.in_project(fn _ -> Build.Document.compile(document) end) end {elapsed_us, result} = :timer.tc(fn -> safe_compile_func.() end) @@ -174,8 +174,8 @@ defmodule Engine.Build.State do diagnostics: List.wrap(diagnostics) ) - RemoteControl.broadcast(compile_message) - RemoteControl.broadcast(diagnostics) + Engine.broadcast(compile_message) + Engine.broadcast(diagnostics) Plugin.diagnose(project, state.build_number, document) end) @@ -185,7 +185,7 @@ defmodule Engine.Build.State do def set_compiler_options do Code.compiler_options( parser_options: parser_options(), - tracers: [RemoteControl.Compilation.Tracer] + tracers: [Engine.Compilation.Tracer] ) :ok diff --git a/engine/lib/engine/code_action/handlers/add_alias.ex b/engine/lib/engine/code_action/handlers/add_alias.ex index 6edc635b..36e1387a 100644 --- a/engine/lib/engine/code_action/handlers/add_alias.ex +++ b/engine/lib/engine/code_action/handlers/add_alias.ex @@ -167,7 +167,7 @@ defmodule Engine.CodeAction.Handlers.AddAlias do {:elixir, split} = Ast.Module.safe_split(module) alias_as = List.last(split) subject_module = module - RemoteControl.Module.Loader.ensure_loaded(subject_module) + Engine.Module.Loader.ensure_loaded(subject_module) protocol_or_implementation? = function_exported?(module, :__impl__, 1) diff --git a/engine/lib/engine/code_action/handlers/replace_remote_function.ex b/engine/lib/engine/code_action/handlers/replace_remote_function.ex index 7308a1b6..3902b35b 100644 --- a/engine/lib/engine/code_action/handlers/replace_remote_function.ex +++ b/engine/lib/engine/code_action/handlers/replace_remote_function.ex @@ -60,7 +60,7 @@ defmodule Engine.CodeAction.Handlers.ReplaceRemoteFunction do |> Ast.traverse_line(line_number, [], fn %Zipper{node: {{:., _, [{:__aliases__, _, module_alias}, ^function_atom]}, _, _}} = zipper, patches -> - case RemoteControl.Analyzer.expand_alias(module_alias, analysis, position) do + case Engine.Analyzer.expand_alias(module_alias, analysis, position) do {:ok, ^module} -> patch = Sourceror.Patch.rename_call(zipper.node, suggestion) {zipper, [patch | patches]} diff --git a/engine/lib/engine/code_intelligence/entity.ex b/engine/lib/engine/code_intelligence/entity.ex index 95bddc95..cdd3a5d6 100644 --- a/engine/lib/engine/code_intelligence/entity.ex +++ b/engine/lib/engine/code_intelligence/entity.ex @@ -85,7 +85,7 @@ defmodule Engine.CodeIntelligence.Entity do when def in [:def, :defp, :defmacro, :defmacrop] -> # This case handles resolving calls that come from zero-arg definitions in # a module, like hovering in `def my_fun| do` - {:ok, module} = RemoteControl.Analyzer.current_module(analysis, position) + {:ok, module} = Engine.Analyzer.current_module(analysis, position) {:ok, {:call, module, maybe_fun, 0}, node_range} {:ok, [{^maybe_fun, _, args} | _]} -> @@ -152,7 +152,7 @@ defmodule Engine.CodeIntelligence.Entity do with {:ok, path} <- Ast.path_at(analysis, position), arity = arity_at_position(path, position), {module, ^fun, ^arity} <- - RemoteControl.Analyzer.resolve_local_call(analysis, position, fun, arity) do + Engine.Analyzer.resolve_local_call(analysis, position, fun, arity) do {:ok, {:call, module, fun, arity}, node_range} else _ -> @@ -222,9 +222,9 @@ defmodule Engine.CodeIntelligence.Entity do end defp maybe_prepend_ecto_schema(module_string, %Analysis{} = analysis, %Position{} = position) do - with true <- Ecto.Schema in RemoteControl.Analyzer.uses_at(analysis, position), + with true <- Ecto.Schema in Engine.Analyzer.uses_at(analysis, position), true <- in_inline_embed?(analysis, position), - {:ok, parent_module} <- RemoteControl.Analyzer.current_module(analysis, position) do + {:ok, parent_module} <- Engine.Analyzer.current_module(analysis, position) do parent_module |> Module.concat(module_string) |> Formats.module() @@ -254,7 +254,7 @@ defmodule Engine.CodeIntelligence.Entity do defp maybe_prepend_phoenix_scope_module(module_string, analysis, position) do with {:ok, scope_segments} <- fetch_phoenix_scope_alias_segments(analysis, position), {:ok, scope_module} <- - RemoteControl.Analyzer.expand_alias(scope_segments, analysis, position), + Engine.Analyzer.expand_alias(scope_segments, analysis, position), cursor_module = Module.concat(scope_module, module_string), true <- phoenix_controller_module?(cursor_module) or phoenix_liveview_module?(cursor_module) do @@ -376,7 +376,7 @@ defmodule Engine.CodeIntelligence.Entity do defp expand_alias(module, analysis, %Position{} = position) when is_binary(module) do [module] |> Module.concat() - |> RemoteControl.Analyzer.expand_alias(analysis, position) + |> Engine.Analyzer.expand_alias(analysis, position) end defp expand_alias(_, _analysis, _position), do: :error @@ -482,7 +482,7 @@ defmodule Engine.CodeIntelligence.Entity do defp fetch_module_for_imported_function(analysis, position, function_name, arity) do analysis - |> RemoteControl.Analyzer.imports_at(position) + |> Engine.Analyzer.imports_at(position) |> Enum.find_value({:error, :not_found}, fn {imported_module, ^function_name, ^arity} -> {:ok, imported_module} @@ -493,7 +493,7 @@ defmodule Engine.CodeIntelligence.Entity do end defp fetch_module_for_local_function(analysis, position, function_name, arity) do - with {:ok, current_module} <- RemoteControl.Analyzer.current_module(analysis, position), + with {:ok, current_module} <- Engine.Analyzer.current_module(analysis, position), true <- function_exported?(current_module, function_name, arity) do {:ok, current_module} else @@ -507,7 +507,7 @@ defmodule Engine.CodeIntelligence.Entity do end defp current_module(%Analysis{} = analysis, %Position{} = position) do - case RemoteControl.Analyzer.current_module(analysis, position) do + case Engine.Analyzer.current_module(analysis, position) do {:ok, module} -> module _ -> nil end diff --git a/engine/lib/engine/code_intelligence/structs.ex b/engine/lib/engine/code_intelligence/structs.ex index ea9018c3..019869f2 100644 --- a/engine/lib/engine/code_intelligence/structs.ex +++ b/engine/lib/engine/code_intelligence/structs.ex @@ -8,7 +8,7 @@ defmodule Engine.CodeIntelligence.Structs do if Mix.Project.get() do {:ok, structs_from_index()} else - RemoteControl.Mix.in_project(fn _ -> structs_from_index() end) + Engine.Mix.in_project(fn _ -> structs_from_index() end) end end diff --git a/engine/lib/engine/code_mod/aliases.ex b/engine/lib/engine/code_mod/aliases.ex index 0eefc338..8a41b159 100644 --- a/engine/lib/engine/code_mod/aliases.ex +++ b/engine/lib/engine/code_mod/aliases.ex @@ -234,7 +234,7 @@ defmodule Engine.CodeMod.Aliases do end defp maybe_move_cursor_to_token_start(%Position{} = position, %Analysis{} = analysis) do - project = RemoteControl.get_project() + project = Engine.get_project() with {:ok, env} <- Ast.Env.new(project, analysis, position), false <- String.last(env.prefix) in [" ", ""] do diff --git a/engine/lib/engine/code_mod/format.ex b/engine/lib/engine/code_mod/format.ex index eb03284d..5142fd0e 100644 --- a/engine/lib/engine/code_mod/format.ex +++ b/engine/lib/engine/code_mod/format.ex @@ -97,7 +97,7 @@ defmodule Engine.CodeMod.Format do @spec edits(Document.t()) :: {:ok, Changes.t()} | {:error, any} def edits(%Document{} = document) do - project = RemoteControl.get_project() + project = Engine.get_project() with :ok <- Build.compile_document(project, document), {:ok, formatted} <- do_format(project, document) do @@ -163,8 +163,8 @@ defmodule Engine.CodeMod.Format do fetch_formatter = fn _ -> Mix.Tasks.Format.formatter_for_file(file_path) end {formatter_function, opts} = - if RemoteControl.project_node?() do - case RemoteControl.Mix.in_project(project, fetch_formatter) do + if Engine.project_node?() do + case Engine.Mix.in_project(project, fetch_formatter) do {:ok, result} -> result diff --git a/engine/lib/engine/commands/reindex.ex b/engine/lib/engine/commands/reindex.ex index 8634515c..1e919a7b 100644 --- a/engine/lib/engine/commands/reindex.ex +++ b/engine/lib/engine/commands/reindex.ex @@ -89,7 +89,7 @@ defmodule Engine.Commands.Reindex do end def perform do - perform(RemoteControl.get_project()) + perform(Engine.get_project()) end def perform(%Project{} = project) do @@ -144,7 +144,7 @@ defmodule Engine.Commands.Reindex do end defp do_reindex(%Project{} = project) do - RemoteControl.broadcast(project_reindex_requested(project: project)) + Engine.broadcast(project_reindex_requested(project: project)) {elapsed_us, result} = :timer.tc(fn -> @@ -153,7 +153,7 @@ defmodule Engine.Commands.Reindex do end end) - RemoteControl.broadcast( + Engine.broadcast( project_reindexed(project: project, elapsed_ms: round(elapsed_us / 1000), status: :success) ) diff --git a/engine/lib/engine/compilation/tracer.ex b/engine/lib/engine/compilation/tracer.ex index 5296f3ab..65df408b 100644 --- a/engine/lib/engine/compilation/tracer.ex +++ b/engine/lib/engine/compilation/tracer.ex @@ -3,12 +3,12 @@ defmodule Engine.Compilation.Tracer do alias Engine.Build alias Engine.Module.Loader - import RemoteControl.Api.Messages + import Engine.Api.Messages def trace({:on_module, module_binary, _filename}, %Macro.Env{} = env) do message = extract_module_updated(env.module, module_binary, env.file) maybe_report_progress(env.file) - RemoteControl.broadcast(message) + Engine.broadcast(message) :ok end @@ -60,7 +60,7 @@ defmodule Engine.Compilation.Tracer do if Path.extname(file) == ".ex" do file |> progress_message() - |> RemoteControl.broadcast() + |> Engine.broadcast() end end @@ -75,7 +75,7 @@ defmodule Engine.Compilation.Tracer do message = "compiling: " <> Path.join([base_dir, "...", file_name]) - label = Build.State.building_label(RemoteControl.get_project()) + label = Build.State.building_label(Engine.get_project()) project_progress(label: label, message: message) end end diff --git a/engine/lib/engine/completion.ex b/engine/lib/engine/completion.ex index 4b7b150d..a8128b92 100644 --- a/engine/lib/engine/completion.ex +++ b/engine/lib/engine/completion.ex @@ -62,7 +62,7 @@ defmodule Engine.Completion do |> container_struct_module() with {:ok, struct_module} <- - RemoteControl.Analyzer.expand_alias(container_struct_module, analysis, position), + Engine.Analyzer.expand_alias(container_struct_module, analysis, position), true <- function_exported?(struct_module, :__struct__, 0) do struct_module |> struct() diff --git a/engine/lib/engine/dispatch.ex b/engine/lib/engine/dispatch.ex index e7bdc384..320ba3a6 100644 --- a/engine/lib/engine/dispatch.ex +++ b/engine/lib/engine/dispatch.ex @@ -77,8 +77,8 @@ defmodule Engine.Dispatch do end defp progress_pid do - project = RemoteControl.get_project() - manager_node_name = RemoteControl.manager_node_name(project) + project = Engine.get_project() + manager_node_name = Engine.manager_node_name(project) :rpc.call(manager_node_name, Lexical.Server.Project.Progress, :whereis, [project]) end end diff --git a/engine/lib/engine/mix.ex b/engine/lib/engine/mix.ex index 9536989b..b9e21563 100644 --- a/engine/lib/engine/mix.ex +++ b/engine/lib/engine/mix.ex @@ -3,8 +3,8 @@ defmodule Engine.Mix do alias Engine def in_project(fun) do - if RemoteControl.project_node?() do - in_project(RemoteControl.get_project(), fun) + if Engine.project_node?() do + in_project(Engine.get_project(), fun) else {:error, :not_project_node} end @@ -20,7 +20,7 @@ defmodule Engine.Mix do try do Mix.ProjectStack.post_config(prune_code_paths: false) - build_path = RemoteControl.Build.path(project) + build_path = Engine.Build.path(project) project_root = Project.root_path(project) project @@ -49,6 +49,6 @@ defmodule Engine.Mix do end defp with_lock(fun) do - RemoteControl.with_lock(__MODULE__, fun) + Engine.with_lock(__MODULE__, fun) end end diff --git a/engine/lib/engine/module_mappings.ex b/engine/lib/engine/module_mappings.ex index e56eeea6..6e5970d6 100644 --- a/engine/lib/engine/module_mappings.ex +++ b/engine/lib/engine/module_mappings.ex @@ -63,7 +63,7 @@ defmodule Engine.ModuleMappings do @impl GenServer def init(_) do - RemoteControl.register_listener(self(), [module_updated()]) + Engine.register_listener(self(), [module_updated()]) {:ok, State.new()} end diff --git a/engine/lib/engine/plugin.ex b/engine/lib/engine/plugin.ex index 17167bdf..be9215f9 100644 --- a/engine/lib/engine/plugin.ex +++ b/engine/lib/engine/plugin.ex @@ -20,7 +20,7 @@ defmodule Engine.Plugin do diagnostics: diagnostics ) - RemoteControl.broadcast(message) + Engine.broadcast(message) end Runner.diagnose(project, on_complete) @@ -40,7 +40,7 @@ defmodule Engine.Plugin do diagnostics: diagnostics ) - RemoteControl.broadcast(message) + Engine.broadcast(message) end Runner.diagnose(document, on_complete) diff --git a/engine/lib/engine/port.ex b/engine/lib/engine/port.ex index 29e73ef9..fd110f6e 100644 --- a/engine/lib/engine/port.ex +++ b/engine/lib/engine/port.ex @@ -18,11 +18,11 @@ defmodule Engine.Port do Launches elixir in a port. This function takes the project's context into account and looks for the executable via calling - `RemoteControl.elixir_executable(project)`. Environment variables are also retrieved with that call. + `Engine.elixir_executable(project)`. Environment variables are also retrieved with that call. """ @spec open_elixir(Project.t(), open_opts()) :: port() def open_elixir(%Project{} = project, opts) do - {:ok, elixir_executable, environment_variables} = RemoteControl.elixir_executable(project) + {:ok, elixir_executable, environment_variables} = Engine.elixir_executable(project) opts = opts diff --git a/engine/lib/engine/progress.ex b/engine/lib/engine/progress.ex index 0730dfce..5dcb60d1 100644 --- a/engine/lib/engine/progress.ex +++ b/engine/lib/engine/progress.ex @@ -41,26 +41,26 @@ defmodule Engine.Progress do @spec begin_progress(label :: label()) :: on_complete_callback() def begin_progress(label) do - RemoteControl.broadcast(project_progress(label: label, stage: :begin)) + Engine.broadcast(project_progress(label: label, stage: :begin)) fn -> - RemoteControl.broadcast(project_progress(label: label, stage: :complete)) + Engine.broadcast(project_progress(label: label, stage: :complete)) end end @spec begin_percent(label(), pos_integer()) :: {report_progress_callback(), on_complete_callback()} def begin_percent(label, max) do - RemoteControl.broadcast(percent_progress(label: label, max: max, stage: :begin)) + Engine.broadcast(percent_progress(label: label, max: max, stage: :begin)) report_progress = fn delta, message -> - RemoteControl.broadcast( + Engine.broadcast( percent_progress(label: label, message: message, delta: delta, stage: :report) ) end complete = fn -> - RemoteControl.broadcast(percent_progress(label: label, stage: :complete)) + Engine.broadcast(percent_progress(label: label, stage: :complete)) end {report_progress, complete} diff --git a/engine/lib/engine/project_node.ex b/engine/lib/engine/project_node.ex index 311b40a6..a31312f3 100644 --- a/engine/lib/engine/project_node.ex +++ b/engine/lib/engine/project_node.ex @@ -40,7 +40,7 @@ defmodule Engine.ProjectNode do | path_append_arguments(paths) ] - port = RemoteControl.Port.open_elixir(state.project, args: args) + port = Engine.Port.open_elixir(state.project, args: args) %{state | port: port, started_by: from} end @@ -114,7 +114,7 @@ defmodule Engine.ProjectNode do with {:ok, node_pid} <- ProjectNodeSupervisor.start_project_node(project), :ok <- start_node(project, paths), - :ok <- :rpc.call(node_name, RemoteControl.Bootstrap, :init, bootstrap_args) do + :ok <- :rpc.call(node_name, Engine.Bootstrap, :init, bootstrap_args) do {:ok, node_pid} end end diff --git a/engine/lib/engine/search/fuzzy.ex b/engine/lib/engine/search/fuzzy.ex index d051dd22..948d98d4 100644 --- a/engine/lib/engine/search/fuzzy.ex +++ b/engine/lib/engine/search/fuzzy.ex @@ -340,7 +340,7 @@ defmodule Engine.Search.Fuzzy do deps_roots() else {:ok, deps_roots} = - RemoteControl.Mix.in_project(fn _ -> + Engine.Mix.in_project(fn _ -> deps_roots() end) @@ -359,7 +359,7 @@ defmodule Engine.Search.Fuzzy do end defp deps_roots do - deps_roots(RemoteControl.get_project()) + deps_roots(Engine.get_project()) end defp deps_roots(%Project{mix_project?: true} = project) do diff --git a/engine/lib/engine/search/indexer.ex b/engine/lib/engine/search/indexer.ex index 498fe6cf..f78ca572 100644 --- a/engine/lib/engine/search/indexer.ex +++ b/engine/lib/engine/search/indexer.ex @@ -196,14 +196,14 @@ defmodule Engine.Search.Indexer do end defp deps_dir do - case RemoteControl.Mix.in_project(&Mix.Project.deps_path/0) do + case Engine.Mix.in_project(&Mix.Project.deps_path/0) do {:ok, path} -> path _ -> Mix.Project.deps_path() end end defp build_dir do - case RemoteControl.Mix.in_project(&Mix.Project.build_path/0) do + case Engine.Mix.in_project(&Mix.Project.build_path/0) do {:ok, path} -> path _ -> Mix.Project.build_path() end diff --git a/engine/lib/engine/search/indexer/extractors/function_reference.ex b/engine/lib/engine/search/indexer/extractors/function_reference.ex index 80502a39..e52ed33d 100644 --- a/engine/lib/engine/search/indexer/extractors/function_reference.ex +++ b/engine/lib/engine/search/indexer/extractors/function_reference.ex @@ -64,7 +64,7 @@ defmodule Engine.Search.Indexer.Extractors.FunctionReference do position = Reducer.position(reducer) {module, _, _} = - RemoteControl.Analyzer.resolve_local_call(reducer.analysis, position, fn_name, arity) + Engine.Analyzer.resolve_local_call(reducer.analysis, position, fn_name, arity) entry = entry(reducer, end_metadata, arity_meta, module, fn_name, arity) {:ok, entry, nil} @@ -133,7 +133,7 @@ defmodule Engine.Search.Indexer.Extractors.FunctionReference do position = Reducer.position(reducer) {module, _, _} = - RemoteControl.Analyzer.resolve_local_call(reducer.analysis, position, fn_name, arity) + Engine.Analyzer.resolve_local_call(reducer.analysis, position, fn_name, arity) entry = entry(reducer, meta, meta, [module], fn_name, args) @@ -159,7 +159,7 @@ defmodule Engine.Search.Indexer.Extractors.FunctionReference do range = get_reference_range(reducer.analysis.document, start_metadata, end_metadata, function_name) - case RemoteControl.Analyzer.expand_alias(module, reducer.analysis, range.start) do + case Engine.Analyzer.expand_alias(module, reducer.analysis, range.start) do {:ok, module} -> mfa = Subject.mfa(module, function_name, arity) diff --git a/engine/lib/engine/search/indexer/extractors/module.ex b/engine/lib/engine/search/indexer/extractors/module.ex index 3f9c7ee2..af9d1c23 100644 --- a/engine/lib/engine/search/indexer/extractors/module.ex +++ b/engine/lib/engine/search/indexer/extractors/module.ex @@ -128,7 +128,7 @@ defmodule Engine.Search.Indexer.Extractors.Module do line = Sourceror.get_line(ast) pos = Position.new(reducer.analysis.document, line - 1, 1) - case RemoteControl.Analyzer.current_module(reducer.analysis, pos) do + case Engine.Analyzer.current_module(reducer.analysis, pos) do {:ok, current_module} -> {start_line, start_col} = Metadata.position(metadata) start_pos = Position.new(reducer.analysis.document, start_line, start_col) @@ -250,7 +250,7 @@ defmodule Engine.Search.Indexer.Extractors.Module do defp resolve_alias(%Reducer{} = reducer, unresolved_alias) do position = Reducer.position(reducer) - RemoteControl.Analyzer.expand_alias(unresolved_alias, reducer.analysis, position) + Engine.Analyzer.expand_alias(unresolved_alias, reducer.analysis, position) end defp module(%Reducer{} = reducer, maybe_module) when is_list(maybe_module) do diff --git a/engine/lib/engine/search/store.ex b/engine/lib/engine/search/store.ex index 9cbd5d25..2310b590 100644 --- a/engine/lib/engine/search/store.ex +++ b/engine/lib/engine/search/store.ex @@ -130,7 +130,7 @@ defmodule Engine.Search.Store do # we have this bandaid. We wait for the first compilation to complete, and then # the search store enables itself, at which point we index the code. - RemoteControl.register_listener(self(), project_compiled()) + Engine.register_listener(self(), project_compiled()) state = State.new(project, create_index, update_index, backend) {:ok, state} end diff --git a/engine/lib/engine/search/store/backends/ets.ex b/engine/lib/engine/search/store/backends/ets.ex index eb17bd18..ca606101 100644 --- a/engine/lib/engine/search/store/backends/ets.ex +++ b/engine/lib/engine/search/store/backends/ets.ex @@ -94,7 +94,7 @@ defmodule Engine.Search.Store.Backends.Ets do end def start_link do - start_link(RemoteControl.get_project()) + start_link(Engine.get_project()) end def child_spec([%Project{}] = init_args) do @@ -102,7 +102,7 @@ defmodule Engine.Search.Store.Backends.Ets do end def child_spec(_) do - child_spec([RemoteControl.get_project()]) + child_spec([Engine.get_project()]) end @impl GenServer @@ -179,7 +179,7 @@ defmodule Engine.Search.Store.Backends.Ets do end defp genserver_name do - genserver_name(RemoteControl.get_project()) + genserver_name(Engine.get_project()) end defp genserver_name(%Project{} = project) do From 82ba5110e9b60c226ed945a34c85009c39494c2e Mon Sep 17 00:00:00 2001 From: Mitchell Hanberg Date: Wed, 1 Jan 2025 12:07:54 -0500 Subject: [PATCH 04/12] wip: remove redundant alias calls --- engine/lib/engine.ex | 2 +- engine/lib/engine/api.ex | 2 +- engine/lib/engine/api/proxy.ex | 2 +- .../lib/engine/api/proxy/buffering_state.ex | 2 +- engine/lib/engine/application.ex | 2 -- engine/lib/engine/bootstrap.ex | 2 +- engine/lib/engine/build.ex | 2 +- engine/lib/engine/build/project.ex | 30 +++++++++---------- engine/lib/engine/build/state.ex | 2 +- .../engine/code_action/handlers/add_alias.ex | 2 +- .../handlers/replace_remote_function.ex | 2 +- engine/lib/engine/code_intelligence/entity.ex | 2 +- .../lib/engine/code_intelligence/structs.ex | 1 - engine/lib/engine/code_mod/aliases.ex | 2 +- engine/lib/engine/code_mod/format.ex | 2 +- engine/lib/engine/commands/reindex.ex | 2 +- engine/lib/engine/compilation/tracer.ex | 1 - engine/lib/engine/completion.ex | 2 +- engine/lib/engine/dispatch.ex | 2 +- engine/lib/engine/mix.ex | 1 - engine/lib/engine/module_mappings.ex | 1 - engine/lib/engine/plugin.ex | 2 +- engine/lib/engine/port.ex | 1 - engine/lib/engine/progress.ex | 2 -- engine/lib/engine/project_node.ex | 2 +- engine/lib/engine/search/fuzzy.ex | 2 +- engine/lib/engine/search/indexer.ex | 2 +- .../indexer/extractors/function_reference.ex | 2 +- .../search/indexer/extractors/module.ex | 2 +- engine/lib/engine/search/store.ex | 2 +- .../lib/engine/search/store/backends/ets.ex | 2 +- .../search/store/backends/ets/schemas/v1.ex | 8 ++--- .../search/store/backends/ets/schemas/v2.ex | 12 ++++---- .../search/store/backends/ets/schemas/v3.ex | 12 ++++---- 34 files changed, 54 insertions(+), 63 deletions(-) diff --git a/engine/lib/engine.ex b/engine/lib/engine.ex index aaca3f2e..5b18f323 100644 --- a/engine/lib/engine.ex +++ b/engine/lib/engine.ex @@ -6,7 +6,7 @@ defmodule Engine do """ alias Lexical.Project - alias Engine + alias Engine.Api.Proxy alias Engine.CodeAction alias Engine.CodeIntelligence diff --git a/engine/lib/engine/api.ex b/engine/lib/engine/api.ex index 28ccca39..39c782c9 100644 --- a/engine/lib/engine/api.ex +++ b/engine/lib/engine/api.ex @@ -5,7 +5,7 @@ defmodule Engine.Api do alias Lexical.Document.Position alias Lexical.Document.Range alias Lexical.Project - alias Engine + alias Engine.CodeIntelligence require Logger diff --git a/engine/lib/engine/api/proxy.ex b/engine/lib/engine/api/proxy.ex index bbe847a3..a677e6cf 100644 --- a/engine/lib/engine/api/proxy.ex +++ b/engine/lib/engine/api/proxy.ex @@ -32,7 +32,7 @@ defmodule Engine.Api.Proxy do alias Lexical.Document alias Lexical.Document.Changes - alias Engine + alias Engine.Api.Messages alias Engine.Api.Proxy.BufferingState alias Engine.Api.Proxy.DrainingState diff --git a/engine/lib/engine/api/proxy/buffering_state.ex b/engine/lib/engine/api/proxy/buffering_state.ex index be1522d2..f9aa9e50 100644 --- a/engine/lib/engine/api/proxy/buffering_state.ex +++ b/engine/lib/engine/api/proxy/buffering_state.ex @@ -1,6 +1,6 @@ defmodule Engine.Api.Proxy.BufferingState do alias Lexical.Document - alias Engine + alias Engine.Api alias Engine.Build alias Engine.Commands diff --git a/engine/lib/engine/application.ex b/engine/lib/engine/application.ex index 0ae2dc47..395909f0 100644 --- a/engine/lib/engine/application.ex +++ b/engine/lib/engine/application.ex @@ -1,8 +1,6 @@ defmodule Engine.Application do @moduledoc false - alias Engine - use Application require Logger diff --git a/engine/lib/engine/bootstrap.ex b/engine/lib/engine/bootstrap.ex index 053971fd..74421fe4 100644 --- a/engine/lib/engine/bootstrap.ex +++ b/engine/lib/engine/bootstrap.ex @@ -7,7 +7,7 @@ defmodule Engine.Bootstrap do point, it's safe to start the project, as we should have all the code present to compile the system. """ alias Lexical.Project - alias Engine + require Logger def init(%Project{} = project, document_store_entropy, app_configs) do diff --git a/engine/lib/engine/build.ex b/engine/lib/engine/build.ex index e52413d9..df81b4eb 100644 --- a/engine/lib/engine/build.ex +++ b/engine/lib/engine/build.ex @@ -1,7 +1,7 @@ defmodule Engine.Build do alias Lexical.Document alias Lexical.Project - alias Engine + alias Engine.Build.Document.Compilers.HEEx alias Engine.Build.State alias Lexical.VM.Versions diff --git a/engine/lib/engine/build/project.ex b/engine/lib/engine/build/project.ex index 0263f474..dd7bf856 100644 --- a/engine/lib/engine/build/project.ex +++ b/engine/lib/engine/build/project.ex @@ -1,6 +1,6 @@ defmodule Engine.Build.Project do alias Lexical.Project - alias Engine + alias Engine.Build alias Engine.Build.Isolation alias Engine.Plugin @@ -18,11 +18,11 @@ defmodule Engine.Build.Project do compile_fun = fn -> Mix.Task.clear() - with_progress building_label(project), fn -> + with_progress(building_label(project), fn -> result = compile_in_isolation() Mix.Task.run(:loadpaths) result - end + end) end case compile_fun.() do @@ -72,32 +72,32 @@ defmodule Engine.Build.Project do defp prepare_for_project_build(true = _initial?) do if connected_to_internet?() do - with_progress "mix local.hex", fn -> + with_progress("mix local.hex", fn -> Mix.Task.run("local.hex", ~w(--force --if-missing)) - end + end) - with_progress "mix local.rebar", fn -> + with_progress("mix local.rebar", fn -> Mix.Task.run("local.rebar", ~w(--force --if-missing)) - end + end) - with_progress "mix deps.get", fn -> + with_progress("mix deps.get", fn -> Mix.Task.run("deps.get") - end + end) else Logger.warning("Could not connect to hex.pm, dependencies will not be fetched") end - with_progress "mix loadconfig", fn -> + with_progress("mix loadconfig", fn -> Mix.Task.run(:loadconfig) - end + end) - with_progress "mix deps.compile", fn -> + with_progress("mix deps.compile", fn -> Mix.Task.run("deps.safe_compile", ~w(--skip-umbrella-children)) - end + end) - with_progress "loading plugins", fn -> + with_progress("loading plugins", fn -> Plugin.Discovery.run() - end + end) end defp connected_to_internet? do diff --git a/engine/lib/engine/build/state.ex b/engine/lib/engine/build/state.ex index 208aca72..c56bf90f 100644 --- a/engine/lib/engine/build/state.ex +++ b/engine/lib/engine/build/state.ex @@ -2,7 +2,7 @@ defmodule Engine.Build.State do alias Elixir.Features alias Lexical.Document alias Lexical.Project - alias Engine + alias Engine.Api.Messages alias Engine.Build alias Engine.Plugin diff --git a/engine/lib/engine/code_action/handlers/add_alias.ex b/engine/lib/engine/code_action/handlers/add_alias.ex index 36e1387a..30394833 100644 --- a/engine/lib/engine/code_action/handlers/add_alias.ex +++ b/engine/lib/engine/code_action/handlers/add_alias.ex @@ -7,7 +7,7 @@ defmodule Engine.CodeAction.Handlers.AddAlias do alias Lexical.Document.Position alias Lexical.Document.Range alias Lexical.Formats - alias Engine + alias Engine.Analyzer alias Engine.CodeAction alias Engine.CodeIntelligence.Entity diff --git a/engine/lib/engine/code_action/handlers/replace_remote_function.ex b/engine/lib/engine/code_action/handlers/replace_remote_function.ex index 3902b35b..17579eb7 100644 --- a/engine/lib/engine/code_action/handlers/replace_remote_function.ex +++ b/engine/lib/engine/code_action/handlers/replace_remote_function.ex @@ -4,7 +4,7 @@ defmodule Engine.CodeAction.Handlers.ReplaceRemoteFunction do alias Lexical.Document.Changes alias Lexical.Document.Edit alias Lexical.Document.Range - alias Engine + alias Engine.CodeAction alias Engine.CodeAction.Diagnostic alias Engine.Modules diff --git a/engine/lib/engine/code_intelligence/entity.ex b/engine/lib/engine/code_intelligence/entity.ex index cdd3a5d6..b7290d0a 100644 --- a/engine/lib/engine/code_intelligence/entity.ex +++ b/engine/lib/engine/code_intelligence/entity.ex @@ -6,7 +6,7 @@ defmodule Engine.CodeIntelligence.Entity do alias Lexical.Document.Position alias Lexical.Document.Range alias Lexical.Formats - alias Engine + alias Sourceror.Zipper require Logger diff --git a/engine/lib/engine/code_intelligence/structs.ex b/engine/lib/engine/code_intelligence/structs.ex index 019869f2..bc2cd664 100644 --- a/engine/lib/engine/code_intelligence/structs.ex +++ b/engine/lib/engine/code_intelligence/structs.ex @@ -1,5 +1,4 @@ defmodule Engine.CodeIntelligence.Structs do - alias Engine alias Engine.Module.Loader alias Engine.Search.Indexer.Entry alias Engine.Search.Store diff --git a/engine/lib/engine/code_mod/aliases.ex b/engine/lib/engine/code_mod/aliases.ex index 8a41b159..f706f25f 100644 --- a/engine/lib/engine/code_mod/aliases.ex +++ b/engine/lib/engine/code_mod/aliases.ex @@ -7,7 +7,7 @@ defmodule Engine.CodeMod.Aliases do alias Lexical.Document.Edit alias Lexical.Document.Position alias Lexical.Document.Range - alias Engine + alias Sourceror.Zipper @doc """ diff --git a/engine/lib/engine/code_mod/format.ex b/engine/lib/engine/code_mod/format.ex index 5142fd0e..854c9ecc 100644 --- a/engine/lib/engine/code_mod/format.ex +++ b/engine/lib/engine/code_mod/format.ex @@ -2,7 +2,7 @@ defmodule Engine.CodeMod.Format do alias Lexical.Document alias Lexical.Document.Changes alias Lexical.Project - alias Engine + alias Engine.Build alias Engine.CodeMod.Diff diff --git a/engine/lib/engine/commands/reindex.ex b/engine/lib/engine/commands/reindex.ex index 1e919a7b..cea9a75d 100644 --- a/engine/lib/engine/commands/reindex.ex +++ b/engine/lib/engine/commands/reindex.ex @@ -72,7 +72,7 @@ defmodule Engine.Commands.Reindex do alias Lexical.Document alias Lexical.Project - alias Engine + alias Engine.Api alias Engine.Search diff --git a/engine/lib/engine/compilation/tracer.ex b/engine/lib/engine/compilation/tracer.ex index 65df408b..d4b3a59d 100644 --- a/engine/lib/engine/compilation/tracer.ex +++ b/engine/lib/engine/compilation/tracer.ex @@ -1,5 +1,4 @@ defmodule Engine.Compilation.Tracer do - alias Engine alias Engine.Build alias Engine.Module.Loader diff --git a/engine/lib/engine/completion.ex b/engine/lib/engine/completion.ex index a8128b92..70c0b450 100644 --- a/engine/lib/engine/completion.ex +++ b/engine/lib/engine/completion.ex @@ -3,7 +3,7 @@ defmodule Engine.Completion do alias Lexical.Ast.Env alias Lexical.Document alias Lexical.Document.Position - alias Engine + alias Engine.CodeMod.Format alias Engine.Completion.Candidate diff --git a/engine/lib/engine/dispatch.ex b/engine/lib/engine/dispatch.ex index 320ba3a6..b375c134 100644 --- a/engine/lib/engine/dispatch.ex +++ b/engine/lib/engine/dispatch.ex @@ -6,7 +6,7 @@ defmodule Engine.Dispatch do itself via a call to `register_listener`, while a process must implement the `Engine.Dispatch.Handler` behaviour and add the module to the @handlers module attribute. """ - alias Engine + alias Engine.Dispatch.Handlers alias Engine.Dispatch.PubSub import Engine.Api.Messages diff --git a/engine/lib/engine/mix.ex b/engine/lib/engine/mix.ex index b9e21563..9323a8f6 100644 --- a/engine/lib/engine/mix.ex +++ b/engine/lib/engine/mix.ex @@ -1,6 +1,5 @@ defmodule Engine.Mix do alias Lexical.Project - alias Engine def in_project(fun) do if Engine.project_node?() do diff --git a/engine/lib/engine/module_mappings.ex b/engine/lib/engine/module_mappings.ex index 6e5970d6..c2090dee 100644 --- a/engine/lib/engine/module_mappings.ex +++ b/engine/lib/engine/module_mappings.ex @@ -39,7 +39,6 @@ defmodule Engine.ModuleMappings do end end - alias Engine alias Engine.Api.Messages use GenServer diff --git a/engine/lib/engine/plugin.ex b/engine/lib/engine/plugin.ex index be9215f9..a5f1e3fb 100644 --- a/engine/lib/engine/plugin.ex +++ b/engine/lib/engine/plugin.ex @@ -1,7 +1,7 @@ defmodule Engine.Plugin do alias Lexical.Document alias Lexical.Project - alias Engine + alias Engine.Api.Messages alias Engine.Plugin.Runner diff --git a/engine/lib/engine/port.ex b/engine/lib/engine/port.ex index fd110f6e..cd0c4280 100644 --- a/engine/lib/engine/port.ex +++ b/engine/lib/engine/port.ex @@ -4,7 +4,6 @@ defmodule Engine.Port do """ alias Lexical.Project - alias Engine @type open_opt :: {:env, list()} diff --git a/engine/lib/engine/progress.ex b/engine/lib/engine/progress.ex index 5dcb60d1..ab24e5e8 100644 --- a/engine/lib/engine/progress.ex +++ b/engine/lib/engine/progress.ex @@ -1,6 +1,4 @@ defmodule Engine.Progress do - alias Engine - import Engine.Api.Messages @type label :: String.t() diff --git a/engine/lib/engine/project_node.ex b/engine/lib/engine/project_node.ex index a31312f3..2da921fc 100644 --- a/engine/lib/engine/project_node.ex +++ b/engine/lib/engine/project_node.ex @@ -1,6 +1,6 @@ defmodule Engine.ProjectNode do alias Lexical.Project - alias Engine + require Logger defmodule State do diff --git a/engine/lib/engine/search/fuzzy.ex b/engine/lib/engine/search/fuzzy.ex index 948d98d4..0d768e27 100644 --- a/engine/lib/engine/search/fuzzy.ex +++ b/engine/lib/engine/search/fuzzy.ex @@ -12,7 +12,7 @@ defmodule Engine.Search.Fuzzy do """ alias Lexical.Project - alias Engine + alias Engine.Search.Fuzzy.Scorer alias Engine.Search.Indexer.Entry import Record diff --git a/engine/lib/engine/search/indexer.ex b/engine/lib/engine/search/indexer.ex index f78ca572..543674f1 100644 --- a/engine/lib/engine/search/indexer.ex +++ b/engine/lib/engine/search/indexer.ex @@ -2,7 +2,7 @@ defmodule Engine.Search.Indexer do alias Lexical.Identifier alias Lexical.ProcessCache alias Lexical.Project - alias Engine + alias Engine.Progress alias Engine.Search.Indexer alias Engine.Search.Indexer.Entry diff --git a/engine/lib/engine/search/indexer/extractors/function_reference.ex b/engine/lib/engine/search/indexer/extractors/function_reference.ex index e52ed33d..6d7d264a 100644 --- a/engine/lib/engine/search/indexer/extractors/function_reference.ex +++ b/engine/lib/engine/search/indexer/extractors/function_reference.ex @@ -2,7 +2,7 @@ defmodule Engine.Search.Indexer.Extractors.FunctionReference do alias Lexical.Ast alias Lexical.Document.Position alias Lexical.Document.Range - alias Engine + alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Extractors.FunctionDefinition alias Engine.Search.Indexer.Metadata diff --git a/engine/lib/engine/search/indexer/extractors/module.ex b/engine/lib/engine/search/indexer/extractors/module.ex index af9d1c23..0f0706d5 100644 --- a/engine/lib/engine/search/indexer/extractors/module.ex +++ b/engine/lib/engine/search/indexer/extractors/module.ex @@ -7,7 +7,7 @@ defmodule Engine.Search.Indexer.Extractors.Module do alias Lexical.Document.Position alias Lexical.Document.Range alias Lexical.ProcessCache - alias Engine + alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Metadata alias Engine.Search.Indexer.Source.Block diff --git a/engine/lib/engine/search/store.ex b/engine/lib/engine/search/store.ex index 2310b590..70632090 100644 --- a/engine/lib/engine/search/store.ex +++ b/engine/lib/engine/search/store.ex @@ -4,7 +4,7 @@ defmodule Engine.Search.Store do """ alias Lexical.Project - alias Engine + alias Engine.Api alias Engine.Search.Indexer.Entry alias Engine.Search.Store diff --git a/engine/lib/engine/search/store/backends/ets.ex b/engine/lib/engine/search/store/backends/ets.ex index ca606101..0c260b5d 100644 --- a/engine/lib/engine/search/store/backends/ets.ex +++ b/engine/lib/engine/search/store/backends/ets.ex @@ -1,6 +1,6 @@ defmodule Engine.Search.Store.Backends.Ets do alias Lexical.Project - alias Engine + alias Engine.Search.Indexer.Entry alias Engine.Search.Store.Backend alias Engine.Search.Store.Backends.Ets.State diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v1.ex b/engine/lib/engine/search/store/backends/ets/schemas/v1.ex index 502f81d9..7f076f0e 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/v1.ex +++ b/engine/lib/engine/search/store/backends/ets/schemas/v1.ex @@ -14,16 +14,16 @@ defmodule Engine.Search.Store.Backends.Ets.Schemas.V1 do use Schema, version: 1 - defkey :by_id, [:id, :type, :subtype] + defkey(:by_id, [:id, :type, :subtype]) - defkey :by_subject, [ + defkey(:by_subject, [ :subject, :type, :subtype, :path - ] + ]) - defkey :by_path, [:path] + defkey(:by_path, [:path]) def migrate(entries) do migrated = diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v2.ex b/engine/lib/engine/search/store/backends/ets/schemas/v2.ex index 13fec328..af3e189e 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/v2.ex +++ b/engine/lib/engine/search/store/backends/ets/schemas/v2.ex @@ -5,18 +5,18 @@ defmodule Engine.Search.Store.Backends.Ets.Schemas.V2 do require Entry use Schema, version: 2 - defkey :by_id, [:id, :type, :subtype] + defkey(:by_id, [:id, :type, :subtype]) - defkey :by_subject, [ + defkey(:by_subject, [ :subject, :type, :subtype, :path - ] + ]) - defkey :by_path, [:path] - defkey :by_block_id, [:block_id, :path] - defkey :structure, [:path] + defkey(:by_path, [:path]) + defkey(:by_block_id, [:block_id, :path]) + defkey(:structure, [:path]) def migrate(_) do {:ok, []} diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v3.ex b/engine/lib/engine/search/store/backends/ets/schemas/v3.ex index 19713ca2..c59abc4e 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/v3.ex +++ b/engine/lib/engine/search/store/backends/ets/schemas/v3.ex @@ -5,18 +5,18 @@ defmodule Engine.Search.Store.Backends.Ets.Schemas.V3 do require Entry use Schema, version: 3 - defkey :by_id, [:id, :type, :subtype] + defkey(:by_id, [:id, :type, :subtype]) - defkey :by_subject, [ + defkey(:by_subject, [ :subject, :type, :subtype, :path - ] + ]) - defkey :by_path, [:path] - defkey :by_block_id, [:block_id, :path] - defkey :structure, [:path] + defkey(:by_path, [:path]) + defkey(:by_block_id, [:block_id, :path]) + defkey(:structure, [:path]) def migrate(entries) do migrated = From 64cd13c5884304aa450d663c4cb16239ced5561b Mon Sep 17 00:00:00 2001 From: Mitchell Hanberg Date: Wed, 1 Jan 2025 12:50:38 -0500 Subject: [PATCH 05/12] wip: bring over lexical_shared --- engine/lib/engine/analyzer.ex | 12 +- engine/lib/engine/analyzer/aliases.ex | 8 +- engine/lib/engine/analyzer/imports.ex | 12 +- engine/lib/engine/analyzer/requires.ex | 8 +- engine/lib/engine/analyzer/uses.ex | 6 +- engine/lib/engine/api.ex | 12 +- engine/lib/engine/api/messages.ex | 30 +- engine/lib/engine/api/proxy.ex | 4 +- .../lib/engine/api/proxy/buffering_state.ex | 2 +- engine/lib/engine/api/proxy/records.ex | 2 +- engine/lib/engine/bootstrap.ex | 4 +- engine/lib/engine/build.ex | 6 +- engine/lib/engine/build/document.ex | 2 +- engine/lib/engine/build/document/compiler.ex | 4 +- .../engine/build/document/compilers/config.ex | 4 +- .../engine/build/document/compilers/eex.ex | 4 +- .../engine/build/document/compilers/elixir.ex | 2 +- .../engine/build/document/compilers/heex.ex | 4 +- .../engine/build/document/compilers/quoted.ex | 4 +- engine/lib/engine/build/error.ex | 6 +- engine/lib/engine/build/error/location.ex | 8 +- engine/lib/engine/build/error/parse.ex | 6 +- engine/lib/engine/build/project.ex | 2 +- engine/lib/engine/build/state.ex | 6 +- engine/lib/engine/code_action.ex | 10 +- engine/lib/engine/code_action/diagnostic.ex | 2 +- engine/lib/engine/code_action/handler.ex | 4 +- .../engine/code_action/handlers/add_alias.ex | 16 +- .../code_action/handlers/organize_aliases.ex | 10 +- .../handlers/remove_unused_alias.ex | 14 +- .../handlers/replace_remote_function.ex | 10 +- .../handlers/replace_with_underscore.ex | 8 +- .../engine/code_intelligence/definition.ex | 14 +- engine/lib/engine/code_intelligence/entity.ex | 12 +- .../engine/code_intelligence/references.ex | 8 +- .../lib/engine/code_intelligence/symbols.ex | 4 +- .../code_intelligence/symbols/document.ex | 4 +- .../code_intelligence/symbols/workspace.ex | 10 +- .../lib/engine/code_intelligence/variable.ex | 6 +- engine/lib/engine/code_mod/aliases.ex | 16 +- engine/lib/engine/code_mod/diff.ex | 10 +- engine/lib/engine/code_mod/format.ex | 6 +- engine/lib/engine/commands/reindex.ex | 10 +- engine/lib/engine/completion.ex | 10 +- engine/lib/engine/convertible.ex | 215 +++++++++ engine/lib/engine/dispatch.ex | 2 +- .../lib/engine/dispatch/handlers/indexing.ex | 2 +- engine/lib/engine/dispatch/pub_sub.ex | 4 +- engine/lib/engine/document.ex | 401 +++++++++++++++++ engine/lib/engine/document/changes.ex | 31 ++ engine/lib/engine/document/container.ex | 49 ++ engine/lib/engine/document/edit.ex | 35 ++ engine/lib/engine/document/line.ex | 30 ++ engine/lib/engine/document/line_parser.ex | 109 +++++ engine/lib/engine/document/lines.ex | 175 ++++++++ engine/lib/engine/document/location.ex | 41 ++ engine/lib/engine/document/path.ex | 148 ++++++ engine/lib/engine/document/position.ex | 117 +++++ engine/lib/engine/document/range.ex | 65 +++ engine/lib/engine/document/store.ex | 423 ++++++++++++++++++ engine/lib/{ => engine}/engine.ex | 8 +- engine/lib/engine/formats.ex | 109 +++++ engine/lib/engine/math.ex | 19 + engine/lib/engine/mix.ex | 2 +- engine/lib/engine/plugin.ex | 4 +- engine/lib/engine/plugin/discovery.ex | 4 +- engine/lib/engine/plugin/runner.ex | 4 +- .../lib/engine/plugin/runner/coordinator.ex | 2 +- engine/lib/engine/port.ex | 2 +- engine/lib/engine/process_cache.ex | 116 +++++ engine/lib/engine/project.ex | 324 ++++++++++++++ engine/lib/engine/project_node.ex | 4 +- engine/lib/engine/project_node_supervisor.ex | 2 +- engine/lib/engine/search/fuzzy.ex | 8 +- engine/lib/engine/search/indexer.ex | 6 +- engine/lib/engine/search/indexer/entry.ex | 8 +- .../search/indexer/extractors/ecto_schema.ex | 4 +- .../search/indexer/extractors/ex_unit.ex | 10 +- .../indexer/extractors/function_definition.ex | 4 +- .../indexer/extractors/function_reference.ex | 8 +- .../search/indexer/extractors/module.ex | 8 +- .../indexer/extractors/module_attribute.ex | 6 +- .../indexer/extractors/struct_definition.ex | 2 +- .../indexer/extractors/struct_reference.ex | 2 +- .../search/indexer/extractors/variable.ex | 2 +- engine/lib/engine/search/indexer/quoted.ex | 4 +- engine/lib/engine/search/indexer/source.ex | 4 +- .../lib/engine/search/indexer/source/block.ex | 2 +- .../engine/search/indexer/source/reducer.ex | 4 +- engine/lib/engine/search/store.ex | 2 +- engine/lib/engine/search/store/backend.ex | 2 +- .../lib/engine/search/store/backends/ets.ex | 2 +- .../search/store/backends/ets/schema.ex | 4 +- .../engine/search/store/backends/ets/state.ex | 2 +- .../engine/search/store/backends/ets/wal.ex | 6 +- engine/lib/engine/search/store/state.ex | 2 +- engine/lib/engine/search/subject.ex | 2 +- engine/lib/engine/struct_access.ex | 43 ++ engine/lib/engine/text.ex | 8 + engine/mix.exs | 1 + engine/mix.lock | 1 + 101 files changed, 2706 insertions(+), 240 deletions(-) create mode 100644 engine/lib/engine/convertible.ex create mode 100644 engine/lib/engine/document.ex create mode 100644 engine/lib/engine/document/changes.ex create mode 100644 engine/lib/engine/document/container.ex create mode 100644 engine/lib/engine/document/edit.ex create mode 100644 engine/lib/engine/document/line.ex create mode 100644 engine/lib/engine/document/line_parser.ex create mode 100644 engine/lib/engine/document/lines.ex create mode 100644 engine/lib/engine/document/location.ex create mode 100644 engine/lib/engine/document/path.ex create mode 100644 engine/lib/engine/document/position.ex create mode 100644 engine/lib/engine/document/range.ex create mode 100644 engine/lib/engine/document/store.ex rename engine/lib/{ => engine}/engine.ex (97%) create mode 100644 engine/lib/engine/formats.ex create mode 100644 engine/lib/engine/math.ex create mode 100644 engine/lib/engine/process_cache.ex create mode 100644 engine/lib/engine/project.ex create mode 100644 engine/lib/engine/struct_access.ex create mode 100644 engine/lib/engine/text.ex diff --git a/engine/lib/engine/analyzer.ex b/engine/lib/engine/analyzer.ex index dd024353..83706d21 100644 --- a/engine/lib/engine/analyzer.ex +++ b/engine/lib/engine/analyzer.ex @@ -1,9 +1,9 @@ defmodule Engine.Analyzer do - alias Lexical.Ast - alias Lexical.Ast.Analysis - alias Lexical.Ast.Analysis.Require - alias Lexical.Ast.Analysis.Use - alias Lexical.Document.Position + alias Engine.Ast + alias Engine.Ast.Analysis + alias Engine.Ast.Analysis.Require + alias Engine.Ast.Analysis.Use + alias Engine.Document.Position alias Engine.Analyzer.Aliases alias Engine.Analyzer.Imports alias Engine.Analyzer.Requires @@ -114,7 +114,7 @@ defmodule Engine.Analyzer do ) :: {:ok, module()} | :error def expand_alias([_ | _] = segments, %Analysis{} = analysis, %Position{} = position) do - with %Analysis{valid?: true} = analysis <- Lexical.Ast.reanalyze_to(analysis, position), + with %Analysis{valid?: true} = analysis <- Engine.Ast.reanalyze_to(analysis, position), aliases <- aliases_at(analysis, position), {:ok, resolved} <- resolve_alias(segments, aliases) do {:ok, Module.concat(resolved)} diff --git a/engine/lib/engine/analyzer/aliases.ex b/engine/lib/engine/analyzer/aliases.ex index 09b5d8c5..fea28abf 100644 --- a/engine/lib/engine/analyzer/aliases.ex +++ b/engine/lib/engine/analyzer/aliases.ex @@ -1,8 +1,8 @@ defmodule Engine.Analyzer.Aliases do - alias Lexical.Ast.Analysis - alias Lexical.Ast.Analysis.Alias - alias Lexical.Ast.Analysis.Scope - alias Lexical.Document.Position + alias Engine.Ast.Analysis + alias Engine.Ast.Analysis.Alias + alias Engine.Ast.Analysis.Scope + alias Engine.Document.Position @spec at(Analysis.t(), Position.t()) :: %{atom() => module()} def at(%Analysis{} = analysis, %Position{} = position) do diff --git a/engine/lib/engine/analyzer/imports.ex b/engine/lib/engine/analyzer/imports.ex index e2119aa7..77eb15c3 100644 --- a/engine/lib/engine/analyzer/imports.ex +++ b/engine/lib/engine/analyzer/imports.ex @@ -1,10 +1,10 @@ defmodule Engine.Analyzer.Imports do - alias Lexical.Ast.Analysis - alias Lexical.Ast.Analysis.Import - alias Lexical.Ast.Analysis.Scope - alias Lexical.Document.Position - alias Lexical.Document.Range - alias Lexical.ProcessCache + alias Engine.Ast.Analysis + alias Engine.Ast.Analysis.Import + alias Engine.Ast.Analysis.Scope + alias Engine.Document.Position + alias Engine.Document.Range + alias Engine.ProcessCache alias Engine.Analyzer.Aliases alias Engine.Module.Loader diff --git a/engine/lib/engine/analyzer/requires.ex b/engine/lib/engine/analyzer/requires.ex index 5bc38d20..7ed2c6cf 100644 --- a/engine/lib/engine/analyzer/requires.ex +++ b/engine/lib/engine/analyzer/requires.ex @@ -1,8 +1,8 @@ defmodule Engine.Analyzer.Requires do - alias Lexical.Ast.Analysis - alias Lexical.Ast.Analysis.Require - alias Lexical.Ast.Analysis.Scope - alias Lexical.Document.Position + alias Engine.Ast.Analysis + alias Engine.Ast.Analysis.Require + alias Engine.Ast.Analysis.Scope + alias Engine.Document.Position def at(%Analysis{} = analysis, %Position{} = position) do case Analysis.scopes_at(analysis, position) do diff --git a/engine/lib/engine/analyzer/uses.ex b/engine/lib/engine/analyzer/uses.ex index 1268886a..3001f3ee 100644 --- a/engine/lib/engine/analyzer/uses.ex +++ b/engine/lib/engine/analyzer/uses.ex @@ -1,7 +1,7 @@ defmodule Engine.Analyzer.Uses do - alias Lexical.Ast.Analysis - alias Lexical.Ast.Analysis.Scope - alias Lexical.Document.Position + alias Engine.Ast.Analysis + alias Engine.Ast.Analysis.Scope + alias Engine.Document.Position def at(%Analysis{} = analysis, %Position{} = position) do case Analysis.scopes_at(analysis, position) do diff --git a/engine/lib/engine/api.ex b/engine/lib/engine/api.ex index 39c782c9..fcd24a92 100644 --- a/engine/lib/engine/api.ex +++ b/engine/lib/engine/api.ex @@ -1,10 +1,10 @@ defmodule Engine.Api do - alias Lexical.Ast.Analysis - alias Lexical.Ast.Env - alias Lexical.Document - alias Lexical.Document.Position - alias Lexical.Document.Range - alias Lexical.Project + alias Engine.Ast.Analysis + alias Engine.Ast.Env + alias Engine.Document + alias Engine.Document.Position + alias Engine.Document.Range + alias Engine.Project alias Engine.CodeIntelligence diff --git a/engine/lib/engine/api/messages.ex b/engine/lib/engine/api/messages.ex index 133b05a1..f44e2276 100644 --- a/engine/lib/engine/api/messages.ex +++ b/engine/lib/engine/api/messages.ex @@ -1,5 +1,5 @@ defmodule Engine.Api.Messages do - alias Lexical.Project + alias Engine.Project import Record defrecord :project_compile_requested, project: nil, build_number: 0 @@ -53,12 +53,12 @@ defmodule Engine.Api.Messages do @type project_compile_requested :: record(:project_compile_requested, - project: Lexical.Project.t(), + project: Engine.Project.t(), build_number: non_neg_integer() ) @type project_compiled :: record(:project_compiled, - project: Lexical.Project.t(), + project: Engine.Project.t(), build_number: non_neg_integer(), status: compile_status, elapsed_ms: non_neg_integer @@ -67,13 +67,13 @@ defmodule Engine.Api.Messages do @type filesystem_event :: record(:filesystem_event, project: Project.t(), - uri: Lexical.uri(), + uri: Engine.uri(), event_type: :created | :updated | :deleted ) @type file_changed :: record(:file_changed, - uri: Lexical.uri(), + uri: Engine.uri(), from_version: maybe_version, to_version: maybe_version, open?: boolean() @@ -81,16 +81,16 @@ defmodule Engine.Api.Messages do @type file_compile_requested :: record(:file_compile_requested, - project: Lexical.Project.t(), + project: Engine.Project.t(), build_number: non_neg_integer(), - uri: Lexical.uri() + uri: Engine.uri() ) @type file_compiled :: record(:file_compiled, - project: Lexical.Project.t(), + project: Engine.Project.t(), build_number: non_neg_integer(), - uri: Lexical.uri(), + uri: Engine.uri(), status: compile_status, elapsed_ms: non_neg_integer ) @@ -105,14 +105,14 @@ defmodule Engine.Api.Messages do @type project_diagnostics :: record(:project_diagnostics, - project: Lexical.Project.t(), + project: Engine.Project.t(), diagnostics: diagnostics() ) @type file_diagnostics :: record(:file_diagnostics, - project: Lexical.Project.t(), - uri: Lexical.uri(), + project: Engine.Project.t(), + uri: Engine.uri(), diagnostics: diagnostics() ) @@ -125,14 +125,14 @@ defmodule Engine.Api.Messages do @type struct_discovered :: record(:struct_discovered, module: module(), fields: field_list()) - @type project_index_ready :: record(:project_index_ready, project: Lexical.Project.t()) + @type project_index_ready :: record(:project_index_ready, project: Engine.Project.t()) @type project_reindex_requested :: - record(:project_reindex_requested, project: Lexical.Project.t()) + record(:project_reindex_requested, project: Engine.Project.t()) @type project_reindexed :: record(:project_reindexed, - project: Lexical.Project.t(), + project: Engine.Project.t(), elapsed_ms: non_neg_integer(), status: :success | {:error, term()} ) diff --git a/engine/lib/engine/api/proxy.ex b/engine/lib/engine/api/proxy.ex index a677e6cf..d0b55c95 100644 --- a/engine/lib/engine/api/proxy.ex +++ b/engine/lib/engine/api/proxy.ex @@ -30,8 +30,8 @@ defmodule Engine.Api.Proxy do """ - alias Lexical.Document - alias Lexical.Document.Changes + alias Engine.Document + alias Engine.Document.Changes alias Engine.Api.Messages alias Engine.Api.Proxy.BufferingState diff --git a/engine/lib/engine/api/proxy/buffering_state.ex b/engine/lib/engine/api/proxy/buffering_state.ex index f9aa9e50..362a591a 100644 --- a/engine/lib/engine/api/proxy/buffering_state.ex +++ b/engine/lib/engine/api/proxy/buffering_state.ex @@ -1,5 +1,5 @@ defmodule Engine.Api.Proxy.BufferingState do - alias Lexical.Document + alias Engine.Document alias Engine.Api alias Engine.Build diff --git a/engine/lib/engine/api/proxy/records.ex b/engine/lib/engine/api/proxy/records.ex index add2cf3f..0e53a2fd 100644 --- a/engine/lib/engine/api/proxy/records.ex +++ b/engine/lib/engine/api/proxy/records.ex @@ -1,5 +1,5 @@ defmodule Engine.Api.Proxy.Records do - alias Lexical.Formats + alias Engine.Formats import Record diff --git a/engine/lib/engine/bootstrap.ex b/engine/lib/engine/bootstrap.ex index 74421fe4..366e11f8 100644 --- a/engine/lib/engine/bootstrap.ex +++ b/engine/lib/engine/bootstrap.ex @@ -6,12 +6,12 @@ defmodule Engine.Bootstrap do the project's code paths, which are then added to the code paths from the language server. At this point, it's safe to start the project, as we should have all the code present to compile the system. """ - alias Lexical.Project + alias Engine.Project require Logger def init(%Project{} = project, document_store_entropy, app_configs) do - Lexical.Document.Store.set_entropy(document_store_entropy) + Engine.Document.Store.set_entropy(document_store_entropy) Application.put_all_env(app_configs) diff --git a/engine/lib/engine/build.ex b/engine/lib/engine/build.ex index df81b4eb..feda6877 100644 --- a/engine/lib/engine/build.ex +++ b/engine/lib/engine/build.ex @@ -1,10 +1,10 @@ defmodule Engine.Build do - alias Lexical.Document - alias Lexical.Project + alias Engine.Document + alias Engine.Project alias Engine.Build.Document.Compilers.HEEx alias Engine.Build.State - alias Lexical.VM.Versions + alias Engine.VM.Versions require Logger use GenServer diff --git a/engine/lib/engine/build/document.ex b/engine/lib/engine/build/document.ex index cfeaec5d..9f9a044b 100644 --- a/engine/lib/engine/build/document.ex +++ b/engine/lib/engine/build/document.ex @@ -1,5 +1,5 @@ defmodule Engine.Build.Document do - alias Lexical.Document + alias Engine.Document alias Engine.Build alias Engine.Build.Document.Compilers alias Engine.Build.Isolation diff --git a/engine/lib/engine/build/document/compiler.ex b/engine/lib/engine/build/document/compiler.ex index 955d6b25..9b19eec8 100644 --- a/engine/lib/engine/build/document/compiler.ex +++ b/engine/lib/engine/build/document/compiler.ex @@ -2,8 +2,8 @@ defmodule Engine.Build.Document.Compiler do @moduledoc """ A behaviour for document-level compilers """ - alias Lexical.Document - alias Lexical.Plugin.V1.Diagnostic + alias Engine.Document + alias Engine.Plugin.V1.Diagnostic @type compile_response :: {:ok, [Diagnostic.Result.t()]} | {:error, [Diagnostic.Result.t()]} diff --git a/engine/lib/engine/build/document/compilers/config.ex b/engine/lib/engine/build/document/compilers/config.ex index da717b27..360cb8af 100644 --- a/engine/lib/engine/build/document/compilers/config.ex +++ b/engine/lib/engine/build/document/compilers/config.ex @@ -3,8 +3,8 @@ defmodule Engine.Build.Document.Compilers.Config do A compiler for elixir configuration """ alias Elixir.Features - alias Lexical.Document - alias Lexical.Plugin.V1.Diagnostic + alias Engine.Document + alias Engine.Plugin.V1.Diagnostic alias Engine.Build alias Engine.Build.Error.Location diff --git a/engine/lib/engine/build/document/compilers/eex.ex b/engine/lib/engine/build/document/compilers/eex.ex index c2ccfd90..c6dba628 100644 --- a/engine/lib/engine/build/document/compilers/eex.ex +++ b/engine/lib/engine/build/document/compilers/eex.ex @@ -2,8 +2,8 @@ defmodule Engine.Build.Document.Compilers.EEx do @moduledoc """ A compiler for .eex files """ - alias Lexical.Document - alias Lexical.Plugin.V1.Diagnostic.Result + alias Engine.Document + alias Engine.Plugin.V1.Diagnostic.Result alias Engine.Build alias Engine.Build.Document.Compiler alias Engine.Build.Document.Compilers diff --git a/engine/lib/engine/build/document/compilers/elixir.ex b/engine/lib/engine/build/document/compilers/elixir.ex index 244f20f1..b6c8f96e 100644 --- a/engine/lib/engine/build/document/compilers/elixir.ex +++ b/engine/lib/engine/build/document/compilers/elixir.ex @@ -4,7 +4,7 @@ defmodule Engine.Build.Document.Compilers.Elixir do """ alias Elixir.Features - alias Lexical.Document + alias Engine.Document alias Engine.Build alias Engine.Build.Document.Compilers diff --git a/engine/lib/engine/build/document/compilers/heex.ex b/engine/lib/engine/build/document/compilers/heex.ex index caf5afda..2e093eca 100644 --- a/engine/lib/engine/build/document/compilers/heex.ex +++ b/engine/lib/engine/build/document/compilers/heex.ex @@ -2,8 +2,8 @@ defmodule Engine.Build.Document.Compilers.HEEx do @moduledoc """ A compiler for .heex files """ - alias Lexical.Document - alias Lexical.Plugin.V1.Diagnostic.Result + alias Engine.Document + alias Engine.Plugin.V1.Diagnostic.Result alias Engine.Build.Document.Compiler alias Engine.Build.Document.Compilers require Logger diff --git a/engine/lib/engine/build/document/compilers/quoted.ex b/engine/lib/engine/build/document/compilers/quoted.ex index f90a210d..47570408 100644 --- a/engine/lib/engine/build/document/compilers/quoted.ex +++ b/engine/lib/engine/build/document/compilers/quoted.ex @@ -1,7 +1,7 @@ defmodule Engine.Build.Document.Compilers.Quoted do alias Elixir.Features - alias Lexical.Ast - alias Lexical.Document + alias Engine.Ast + alias Engine.Document alias Engine.Build alias Engine.ModuleMappings diff --git a/engine/lib/engine/build/error.ex b/engine/lib/engine/build/error.ex index 67d980f8..73866541 100644 --- a/engine/lib/engine/build/error.ex +++ b/engine/lib/engine/build/error.ex @@ -1,7 +1,7 @@ defmodule Engine.Build.Error do - alias Lexical.Ast - alias Lexical.Document - alias Lexical.Plugin.V1.Diagnostic.Result + alias Engine.Ast + alias Engine.Document + alias Engine.Plugin.V1.Diagnostic.Result alias Engine.Build.Error.Location alias Mix.Task.Compiler diff --git a/engine/lib/engine/build/error/location.ex b/engine/lib/engine/build/error/location.ex index 10211945..8dc8a903 100644 --- a/engine/lib/engine/build/error/location.ex +++ b/engine/lib/engine/build/error/location.ex @@ -1,8 +1,8 @@ defmodule Engine.Build.Error.Location do - alias Lexical.Document - alias Lexical.Document.Position - alias Lexical.Document.Range - alias Lexical.Plugin.V1.Diagnostic.Result + alias Engine.Document + alias Engine.Document.Position + alias Engine.Document.Range + alias Engine.Plugin.V1.Diagnostic.Result require Logger diff --git a/engine/lib/engine/build/error/parse.ex b/engine/lib/engine/build/error/parse.ex index 9516c764..debeec3e 100644 --- a/engine/lib/engine/build/error/parse.ex +++ b/engine/lib/engine/build/error/parse.ex @@ -1,7 +1,7 @@ defmodule Engine.Build.Error.Parse do - alias Lexical.Document - alias Lexical.Document.Range - alias Lexical.Plugin.V1.Diagnostic.Result + alias Engine.Document + alias Engine.Document.Range + alias Engine.Plugin.V1.Diagnostic.Result alias Engine.Build.Error.Location @elixir_source "Elixir" diff --git a/engine/lib/engine/build/project.ex b/engine/lib/engine/build/project.ex index dd7bf856..9dc9da3d 100644 --- a/engine/lib/engine/build/project.ex +++ b/engine/lib/engine/build/project.ex @@ -1,5 +1,5 @@ defmodule Engine.Build.Project do - alias Lexical.Project + alias Engine.Project alias Engine.Build alias Engine.Build.Isolation diff --git a/engine/lib/engine/build/state.ex b/engine/lib/engine/build/state.ex index c56bf90f..e506e192 100644 --- a/engine/lib/engine/build/state.ex +++ b/engine/lib/engine/build/state.ex @@ -1,12 +1,12 @@ defmodule Engine.Build.State do alias Elixir.Features - alias Lexical.Document - alias Lexical.Project + alias Engine.Document + alias Engine.Project alias Engine.Api.Messages alias Engine.Build alias Engine.Plugin - alias Lexical.VM.Versions + alias Engine.VM.Versions require Logger diff --git a/engine/lib/engine/code_action.ex b/engine/lib/engine/code_action.ex index 3d1f8e4a..55ceaa06 100644 --- a/engine/lib/engine/code_action.ex +++ b/engine/lib/engine/code_action.ex @@ -1,7 +1,7 @@ defmodule Engine.CodeAction do - alias Lexical.Document - alias Lexical.Document.Changes - alias Lexical.Document.Range + alias Engine.Document + alias Engine.Document.Changes + alias Engine.Document.Range alias Engine.CodeAction.Diagnostic alias Engine.CodeAction.Handlers @@ -22,7 +22,7 @@ defmodule Engine.CodeAction do title: String.t(), kind: code_action_kind, changes: Changes.t(), - uri: Lexical.uri() + uri: Engine.uri() } @handlers [ @@ -33,7 +33,7 @@ defmodule Engine.CodeAction do Handlers.RemoveUnusedAlias ] - @spec new(Lexical.uri(), String.t(), code_action_kind(), Changes.t()) :: t() + @spec new(Engine.uri(), String.t(), code_action_kind(), Changes.t()) :: t() def new(uri, title, kind, changes) do %__MODULE__{uri: uri, title: title, changes: changes, kind: kind} end diff --git a/engine/lib/engine/code_action/diagnostic.ex b/engine/lib/engine/code_action/diagnostic.ex index 2e79a935..e7379210 100644 --- a/engine/lib/engine/code_action/diagnostic.ex +++ b/engine/lib/engine/code_action/diagnostic.ex @@ -1,5 +1,5 @@ defmodule Engine.CodeAction.Diagnostic do - alias Lexical.Document.Range + alias Engine.Document.Range defstruct [:range, :message, :source] @type message :: String.t() diff --git a/engine/lib/engine/code_action/handler.ex b/engine/lib/engine/code_action/handler.ex index 8bf17f55..fe1fae4c 100644 --- a/engine/lib/engine/code_action/handler.ex +++ b/engine/lib/engine/code_action/handler.ex @@ -1,6 +1,6 @@ defmodule Engine.CodeAction.Handler do - alias Lexical.Document - alias Lexical.Document.Range + alias Engine.Document + alias Engine.Document.Range alias Engine.CodeAction alias Engine.CodeAction.Diagnostic diff --git a/engine/lib/engine/code_action/handlers/add_alias.ex b/engine/lib/engine/code_action/handlers/add_alias.ex index 30394833..f6dca56a 100644 --- a/engine/lib/engine/code_action/handlers/add_alias.ex +++ b/engine/lib/engine/code_action/handlers/add_alias.ex @@ -1,12 +1,12 @@ defmodule Engine.CodeAction.Handlers.AddAlias do - alias Lexical.Ast - alias Lexical.Ast.Analysis - alias Lexical.Ast.Analysis.Alias - alias Lexical.Document - alias Lexical.Document.Changes - alias Lexical.Document.Position - alias Lexical.Document.Range - alias Lexical.Formats + alias Engine.Ast + alias Engine.Ast.Analysis + alias Engine.Ast.Analysis.Alias + alias Engine.Document + alias Engine.Document.Changes + alias Engine.Document.Position + alias Engine.Document.Range + alias Engine.Formats alias Engine.Analyzer alias Engine.CodeAction diff --git a/engine/lib/engine/code_action/handlers/organize_aliases.ex b/engine/lib/engine/code_action/handlers/organize_aliases.ex index c673b74d..bf662019 100644 --- a/engine/lib/engine/code_action/handlers/organize_aliases.ex +++ b/engine/lib/engine/code_action/handlers/organize_aliases.ex @@ -1,9 +1,9 @@ defmodule Engine.CodeAction.Handlers.OrganizeAliases do - alias Lexical.Ast.Analysis - alias Lexical.Ast.Analysis.Scope - alias Lexical.Document - alias Lexical.Document.Changes - alias Lexical.Document.Range + alias Engine.Ast.Analysis + alias Engine.Ast.Analysis.Scope + alias Engine.Document + alias Engine.Document.Changes + alias Engine.Document.Range alias Engine.CodeAction alias Engine.CodeMod diff --git a/engine/lib/engine/code_action/handlers/remove_unused_alias.ex b/engine/lib/engine/code_action/handlers/remove_unused_alias.ex index df1ea3b4..0737d695 100644 --- a/engine/lib/engine/code_action/handlers/remove_unused_alias.ex +++ b/engine/lib/engine/code_action/handlers/remove_unused_alias.ex @@ -21,13 +21,13 @@ defmodule Engine.CodeAction.Handlers.RemoveUnusedAlias do normalizer and possibly fix sourceror, so until then, this is what we have. """ - alias Lexical.Ast - alias Lexical.Ast.Analysis - alias Lexical.Document - alias Lexical.Document.Changes - alias Lexical.Document.Edit - alias Lexical.Document.Position - alias Lexical.Document.Range + alias Engine.Ast + alias Engine.Ast.Analysis + alias Engine.Document + alias Engine.Document.Changes + alias Engine.Document.Edit + alias Engine.Document.Position + alias Engine.Document.Range alias Engine.Analyzer alias Engine.CodeAction alias Engine.CodeAction.Diagnostic diff --git a/engine/lib/engine/code_action/handlers/replace_remote_function.ex b/engine/lib/engine/code_action/handlers/replace_remote_function.ex index 17579eb7..3d822a85 100644 --- a/engine/lib/engine/code_action/handlers/replace_remote_function.ex +++ b/engine/lib/engine/code_action/handlers/replace_remote_function.ex @@ -1,9 +1,9 @@ defmodule Engine.CodeAction.Handlers.ReplaceRemoteFunction do - alias Lexical.Ast - alias Lexical.Document - alias Lexical.Document.Changes - alias Lexical.Document.Edit - alias Lexical.Document.Range + alias Engine.Ast + alias Engine.Document + alias Engine.Document.Changes + alias Engine.Document.Edit + alias Engine.Document.Range alias Engine.CodeAction alias Engine.CodeAction.Diagnostic diff --git a/engine/lib/engine/code_action/handlers/replace_with_underscore.ex b/engine/lib/engine/code_action/handlers/replace_with_underscore.ex index 19da5de5..c9bd7728 100644 --- a/engine/lib/engine/code_action/handlers/replace_with_underscore.ex +++ b/engine/lib/engine/code_action/handlers/replace_with_underscore.ex @@ -1,8 +1,8 @@ defmodule Engine.CodeAction.Handlers.ReplaceWithUnderscore do - alias Lexical.Ast - alias Lexical.Document - alias Lexical.Document.Changes - alias Lexical.Document.Range + alias Engine.Ast + alias Engine.Document + alias Engine.Document.Changes + alias Engine.Document.Range alias Engine.CodeAction alias Engine.CodeAction.Diagnostic alias Sourceror.Zipper diff --git a/engine/lib/engine/code_intelligence/definition.ex b/engine/lib/engine/code_intelligence/definition.ex index 9e5edfcf..b0f09bd2 100644 --- a/engine/lib/engine/code_intelligence/definition.ex +++ b/engine/lib/engine/code_intelligence/definition.ex @@ -1,16 +1,16 @@ defmodule Engine.CodeIntelligence.Definition do alias ElixirSense.Providers.Location, as: ElixirSenseLocation alias Future.Code - alias Lexical.Ast - alias Lexical.Ast.Analysis - alias Lexical.Document - alias Lexical.Document.Location - alias Lexical.Document.Position - alias Lexical.Formats + alias Engine.Ast + alias Engine.Ast.Analysis + alias Engine.Document + alias Engine.Document.Location + alias Engine.Document.Position + alias Engine.Formats alias Engine.CodeIntelligence.Entity alias Engine.Search.Indexer.Entry alias Engine.Search.Store - alias Lexical.Text + alias Engine.Text require Logger diff --git a/engine/lib/engine/code_intelligence/entity.ex b/engine/lib/engine/code_intelligence/entity.ex index b7290d0a..dd307236 100644 --- a/engine/lib/engine/code_intelligence/entity.ex +++ b/engine/lib/engine/code_intelligence/entity.ex @@ -1,11 +1,11 @@ defmodule Engine.CodeIntelligence.Entity do alias Future.Code, as: Code - alias Lexical.Ast - alias Lexical.Ast.Analysis - alias Lexical.Document - alias Lexical.Document.Position - alias Lexical.Document.Range - alias Lexical.Formats + alias Engine.Ast + alias Engine.Ast.Analysis + alias Engine.Document + alias Engine.Document.Position + alias Engine.Document.Range + alias Engine.Formats alias Sourceror.Zipper diff --git a/engine/lib/engine/code_intelligence/references.ex b/engine/lib/engine/code_intelligence/references.ex index 0b1de7a5..d25f68dd 100644 --- a/engine/lib/engine/code_intelligence/references.ex +++ b/engine/lib/engine/code_intelligence/references.ex @@ -1,8 +1,8 @@ defmodule Engine.CodeIntelligence.References do - alias Lexical.Ast.Analysis - alias Lexical.Document - alias Lexical.Document.Location - alias Lexical.Document.Position + alias Engine.Ast.Analysis + alias Engine.Document + alias Engine.Document.Location + alias Engine.Document.Position alias Engine.Analyzer alias Engine.CodeIntelligence.Entity alias Engine.CodeIntelligence.Variable diff --git a/engine/lib/engine/code_intelligence/symbols.ex b/engine/lib/engine/code_intelligence/symbols.ex index 99822e50..b8b9108c 100644 --- a/engine/lib/engine/code_intelligence/symbols.ex +++ b/engine/lib/engine/code_intelligence/symbols.ex @@ -1,6 +1,6 @@ defmodule Engine.CodeIntelligence.Symbols do - alias Lexical.Document - alias Lexical.Document.Range + alias Engine.Document + alias Engine.Document.Range alias Engine.CodeIntelligence.Symbols alias Engine.Search alias Engine.Search.Indexer diff --git a/engine/lib/engine/code_intelligence/symbols/document.ex b/engine/lib/engine/code_intelligence/symbols/document.ex index 0c02d7d1..d1313720 100644 --- a/engine/lib/engine/code_intelligence/symbols/document.ex +++ b/engine/lib/engine/code_intelligence/symbols/document.ex @@ -1,6 +1,6 @@ defmodule Engine.CodeIntelligence.Symbols.Document do - alias Lexical.Document - alias Lexical.Formats + alias Engine.Document + alias Engine.Formats alias Engine.Search.Indexer.Entry defstruct [:name, :type, :range, :detail_range, :detail, :original_type, :subject, children: []] diff --git a/engine/lib/engine/code_intelligence/symbols/workspace.ex b/engine/lib/engine/code_intelligence/symbols/workspace.ex index 974c1fb2..40610557 100644 --- a/engine/lib/engine/code_intelligence/symbols/workspace.ex +++ b/engine/lib/engine/code_intelligence/symbols/workspace.ex @@ -3,9 +3,9 @@ defmodule Engine.CodeIntelligence.Symbols.Workspace do defstruct [:uri, :range, :detail_range] @type t :: %__MODULE__{ - uri: Lexical.uri(), - range: Lexical.Document.Range.t(), - detail_range: Lexical.Document.Range.t() + uri: Engine.uri(), + range: Engine.Document.Range.t(), + detail_range: Engine.Document.Range.t() } def new(uri, range, detail_range \\ nil) do @@ -13,8 +13,8 @@ defmodule Engine.CodeIntelligence.Symbols.Workspace do end end - alias Lexical.Document - alias Lexical.Formats + alias Engine.Document + alias Engine.Formats alias Engine.Search.Indexer.Entry defstruct [:name, :type, :link, container_name: nil] diff --git a/engine/lib/engine/code_intelligence/variable.ex b/engine/lib/engine/code_intelligence/variable.ex index 6a13ee47..e5a4a213 100644 --- a/engine/lib/engine/code_intelligence/variable.ex +++ b/engine/lib/engine/code_intelligence/variable.ex @@ -1,7 +1,7 @@ defmodule Engine.CodeIntelligence.Variable do - alias Lexical.Ast.Analysis - alias Lexical.Document.Position - alias Lexical.Document.Range + alias Engine.Ast.Analysis + alias Engine.Document.Position + alias Engine.Document.Range alias Engine.Search.Indexer alias Engine.Search.Indexer.Entry diff --git a/engine/lib/engine/code_mod/aliases.ex b/engine/lib/engine/code_mod/aliases.ex index f706f25f..d95c9296 100644 --- a/engine/lib/engine/code_mod/aliases.ex +++ b/engine/lib/engine/code_mod/aliases.ex @@ -1,12 +1,12 @@ defmodule Engine.CodeMod.Aliases do - alias Lexical.Ast - alias Lexical.Ast.Analysis - alias Lexical.Ast.Analysis.Alias - alias Lexical.Ast.Analysis.Scope - alias Lexical.Document - alias Lexical.Document.Edit - alias Lexical.Document.Position - alias Lexical.Document.Range + alias Engine.Ast + alias Engine.Ast.Analysis + alias Engine.Ast.Analysis.Alias + alias Engine.Ast.Analysis.Scope + alias Engine.Document + alias Engine.Document.Edit + alias Engine.Document.Position + alias Engine.Document.Range alias Sourceror.Zipper diff --git a/engine/lib/engine/code_mod/diff.ex b/engine/lib/engine/code_mod/diff.ex index 628c7bf8..94cf21a7 100644 --- a/engine/lib/engine/code_mod/diff.ex +++ b/engine/lib/engine/code_mod/diff.ex @@ -1,9 +1,9 @@ defmodule Engine.CodeMod.Diff do - alias Lexical.CodeUnit - alias Lexical.Document - alias Lexical.Document.Edit - alias Lexical.Document.Position - alias Lexical.Document.Range + alias Engine.CodeUnit + alias Engine.Document + alias Engine.Document.Edit + alias Engine.Document.Position + alias Engine.Document.Range @spec diff(Document.t(), String.t()) :: [Edit.t()] def diff(%Document{} = document, dest) when is_binary(dest) do diff --git a/engine/lib/engine/code_mod/format.ex b/engine/lib/engine/code_mod/format.ex index 854c9ecc..c69255fa 100644 --- a/engine/lib/engine/code_mod/format.ex +++ b/engine/lib/engine/code_mod/format.ex @@ -1,7 +1,7 @@ defmodule Engine.CodeMod.Format do - alias Lexical.Document - alias Lexical.Document.Changes - alias Lexical.Project + alias Engine.Document + alias Engine.Document.Changes + alias Engine.Project alias Engine.Build alias Engine.CodeMod.Diff diff --git a/engine/lib/engine/commands/reindex.ex b/engine/lib/engine/commands/reindex.ex index cea9a75d..8ccb4aad 100644 --- a/engine/lib/engine/commands/reindex.ex +++ b/engine/lib/engine/commands/reindex.ex @@ -1,8 +1,8 @@ defmodule Engine.Commands.Reindex do defmodule State do - alias Lexical.Ast.Analysis - alias Lexical.Document - alias Lexical.ProcessCache + alias Engine.Ast.Analysis + alias Engine.Document + alias Engine.ProcessCache alias Engine.Search alias Engine.Search.Indexer @@ -70,8 +70,8 @@ defmodule Engine.Commands.Reindex do A simple genserver that prevents more than one reindexing job from running at the same time """ - alias Lexical.Document - alias Lexical.Project + alias Engine.Document + alias Engine.Project alias Engine.Api alias Engine.Search diff --git a/engine/lib/engine/completion.ex b/engine/lib/engine/completion.ex index 70c0b450..788f5ba0 100644 --- a/engine/lib/engine/completion.ex +++ b/engine/lib/engine/completion.ex @@ -1,8 +1,8 @@ defmodule Engine.Completion do - alias Lexical.Ast.Analysis - alias Lexical.Ast.Env - alias Lexical.Document - alias Lexical.Document.Position + alias Engine.Ast.Analysis + alias Engine.Ast.Env + alias Engine.Document + alias Engine.Document.Position alias Engine.CodeMod.Format alias Engine.Completion.Candidate @@ -58,7 +58,7 @@ defmodule Engine.Completion do def struct_fields(%Analysis{} = analysis, %Position{} = position) do container_struct_module = analysis - |> Lexical.Ast.cursor_path(position) + |> Engine.Ast.cursor_path(position) |> container_struct_module() with {:ok, struct_module} <- diff --git a/engine/lib/engine/convertible.ex b/engine/lib/engine/convertible.ex new file mode 100644 index 00000000..b1c58dc5 --- /dev/null +++ b/engine/lib/engine/convertible.ex @@ -0,0 +1,215 @@ +defmodule Engine.Convertible.Helpers do + @moduledoc false + + alias Engine.Document + + def apply(%{} = map, func) do + result = + Enum.reduce_while(map, [], fn {key, value}, acc -> + case func.(value) do + {:ok, native} -> + {:cont, [{key, native} | acc]} + + error -> + {:halt, error} + end + end) + + case result do + l when is_list(l) -> + {:ok, Map.new(l)} + + other -> + other + end + end + + def apply(enumerable, func) do + result = + Enum.reduce_while(enumerable, [], fn elem, acc -> + case func.(elem) do + {:ok, native} -> + {:cont, [native | acc]} + + error -> + {:halt, error} + end + end) + + case result do + l when is_list(l) -> + {:ok, Enum.reverse(l)} + + error -> + error + end + end + + def apply(%{} = map, func, context_document) do + Enum.reduce_while(map, [], fn {key, value}, acc -> + context_document = Document.Container.context_document(value, context_document) + + case func.(value, context_document) do + {:ok, native} -> + {:cont, [{key, native} | acc]} + + error -> + {:halt, error} + end + end) + end + + def apply(enumerable, func, context_document) do + result = + Enum.reduce_while(enumerable, [], fn elem, acc -> + context_document = Document.Container.context_document(elem, context_document) + + case func.(elem, context_document) do + {:ok, native} -> + {:cont, [native | acc]} + + error -> + {:halt, error} + end + end) + + case result do + l when is_list(l) -> + Enum.reverse(l) + + error -> + error + end + end +end + +defprotocol Engine.Convertible do + @moduledoc """ + A protocol that details conversions to and from Language Server idioms + + The [Language Server specification](https://microsoft.github.io/language-server-protocol/specifications/lsp/3.17/specification/) + defines a couple of data structures that differ wildly from similar data structures and concepts in Elixir. Among these are + positions and ranges. Elixir's parser thinks in terms of UTF-8 graphemes and uses one-based line and column numbers, while the + language server speaks in UTF-16 code unit offsets and uses zero-based line and character (a misnomer, in reality this is a + UTF-16 code unit) offsets. If not handled centrally, this leads to a profusion of conversion code throughout the language + server codebase. + + That's where this protocol comes in. Using this protocol allows us to define native `Engine.Document.Position` and + `Engine.Document.Range` structs and have them automatically convert into their Language Server counterparts, centralizing + the conversion logic in a single pace. + + Note: You do not need to do conversions manually, If you define a new type, it is sufficient to implement this + protocol for your new type + """ + alias Engine.Document + + @fallback_to_any true + + @typedoc "Any type that can be converted using this protocol" + @type t :: term() + + @typedoc "A native term that contains ranges, positions or both" + @type native :: term() + + @typedoc "A Language server term" + @type lsp :: term() + + @typedoc "The result of converting a lsp term into a native term" + @type native_response :: {:ok, native()} | {:error, term} + + @typedoc "The result of converting a native term into a lsp term" + @type lsp_response :: {:ok, lsp()} | {:error, term} + + @doc """ + Converts the structure to a native implementation + """ + @spec to_native(t, Document.Container.maybe_context_document()) :: native_response() + def to_native(t, context_document) + + @doc """ + Converts the native representation to a LSP compatible struct + """ + @spec to_lsp(t) :: lsp_response() + def to_lsp(t) +end + +defimpl Engine.Convertible, for: List do + alias Engine.Convertible + alias Engine.Convertible.Helpers + + def to_native(l, context_document) do + case Helpers.apply(l, &Convertible.to_native/2, context_document) do + l when is_list(l) -> + {:ok, l} + + error -> + error + end + end + + def to_lsp(l) do + Helpers.apply(l, &Convertible.to_lsp/1) + end +end + +defimpl Engine.Convertible, for: Map do + alias Engine.Convertible + alias Engine.Convertible.Helpers + + def to_native(map, context_document) do + case Helpers.apply(map, &Convertible.to_native/2, context_document) do + l when is_list(l) -> {:ok, Map.new(l)} + error -> error + end + end + + def to_lsp(map) do + Helpers.apply(map, &Convertible.to_lsp/1) + end +end + +defimpl Engine.Convertible, for: Any do + alias Engine.Convertible + alias Engine.Document + alias Engine.Convertible.Helpers + + def to_native(%_struct_module{} = struct, context_document) do + context_document = Document.Container.context_document(struct, context_document) + + result = + struct + |> Map.from_struct() + |> Helpers.apply(&Convertible.to_native/2, context_document) + + case result do + l when is_list(l) -> + {:ok, Map.merge(struct, Map.new(l))} + + error -> + error + end + end + + def to_native(any, _context_document) do + {:ok, any} + end + + def to_lsp(%_struct_module{} = struct) do + result = + struct + |> Map.from_struct() + |> Helpers.apply(&Convertible.to_lsp/1) + + case result do + {:ok, map} -> + {:ok, Map.merge(struct, map)} + + error -> + error + end + end + + def to_lsp(any) do + {:ok, any} + end +end diff --git a/engine/lib/engine/dispatch.ex b/engine/lib/engine/dispatch.ex index b375c134..5ac34565 100644 --- a/engine/lib/engine/dispatch.ex +++ b/engine/lib/engine/dispatch.ex @@ -79,6 +79,6 @@ defmodule Engine.Dispatch do defp progress_pid do project = Engine.get_project() manager_node_name = Engine.manager_node_name(project) - :rpc.call(manager_node_name, Lexical.Server.Project.Progress, :whereis, [project]) + :rpc.call(manager_node_name, Engine.Server.Project.Progress, :whereis, [project]) end end diff --git a/engine/lib/engine/dispatch/handlers/indexing.ex b/engine/lib/engine/dispatch/handlers/indexing.ex index 933f9baf..e7ff0b21 100644 --- a/engine/lib/engine/dispatch/handlers/indexing.ex +++ b/engine/lib/engine/dispatch/handlers/indexing.ex @@ -1,5 +1,5 @@ defmodule Engine.Dispatch.Handlers.Indexing do - alias Lexical.Document + alias Engine.Document alias Engine.Api.Messages alias Engine.Commands alias Engine.Dispatch diff --git a/engine/lib/engine/dispatch/pub_sub.ex b/engine/lib/engine/dispatch/pub_sub.ex index 42df33ee..c14f6b23 100644 --- a/engine/lib/engine/dispatch/pub_sub.ex +++ b/engine/lib/engine/dispatch/pub_sub.ex @@ -3,7 +3,7 @@ defmodule Engine.Dispatch.PubSub do A pubsub event handler for a gen_event controller. """ defmodule State do - alias Lexical.Project + alias Engine.Project defstruct [:registrations] @@ -55,7 +55,7 @@ defmodule Engine.Dispatch.PubSub do end end - alias Lexical.Project + alias Engine.Project @behaviour :gen_event diff --git a/engine/lib/engine/document.ex b/engine/lib/engine/document.ex new file mode 100644 index 00000000..da55a008 --- /dev/null +++ b/engine/lib/engine/document.ex @@ -0,0 +1,401 @@ +defmodule Engine.Document do + @moduledoc """ + A representation of a LSP text document + + A document is the fundamental data structure of the Engine language server. + All language server documents are represented and backed by documents, which + provide functionality for fetching lines, applying changes, and tracking versions. + """ + alias Engine.Convertible + alias Engine.Document.Edit + alias Engine.Document.Line + alias Engine.Document.Lines + alias Engine.Document.Position + alias Engine.Document.Range + alias Engine.Math + + import Engine.Document.Line + + require Logger + + alias __MODULE__.Path, as: DocumentPath + + @derive {Inspect, only: [:path, :version, :dirty?, :lines]} + + defstruct [:uri, :language_id, :path, :version, dirty?: false, lines: nil] + + @type version :: non_neg_integer() + @type fragment_position :: Position.t() | Convertible.t() + @type t :: %__MODULE__{ + uri: String.t(), + language_id: String.t(), + version: version(), + dirty?: boolean, + lines: Lines.t(), + path: String.t() + } + + @type change_application_error :: {:error, {:invalid_range, map()}} + + # public + + @doc """ + Creates a new document from a uri or path, the source code + as a binary and the vewrsion. + """ + @spec new(Engine.path() | Engine.uri(), String.t(), version()) :: t + def new(maybe_uri, text, version, language_id \\ nil) do + uri = DocumentPath.ensure_uri(maybe_uri) + path = DocumentPath.from_uri(uri) + + language_id = + if String.ends_with?(path, ".exs") do + "elixir-script" + else + language_id || language_id_from_path(path) + end + + %__MODULE__{ + uri: uri, + version: version, + lines: Lines.new(text), + path: path, + language_id: language_id + } + end + + @doc """ + Returns the number of lines in the document + + This is a constant time operation. + """ + @spec size(t) :: non_neg_integer() + def size(%__MODULE__{} = document) do + Lines.size(document.lines) + end + + @doc """ + Marks the document file as dirty + + This function is mainly used internally by lexical + """ + @spec mark_dirty(t) :: t + def mark_dirty(%__MODULE__{} = document) do + %__MODULE__{document | dirty?: true} + end + + @doc """ + Marks the document file as clean + + This function is mainly used internally by lexical + """ + @spec mark_clean(t) :: t + def mark_clean(%__MODULE__{} = document) do + %__MODULE__{document | dirty?: false} + end + + @doc """ + Get the text at the given line using `fetch` semantics + + Returns `{:ok, text}` if the line exists, and `:error` if it doesn't. The line text is + returned without the line end character(s). + + This is a constant time operation. + """ + @spec fetch_text_at(t, version()) :: {:ok, String.t()} | :error + def fetch_text_at(%__MODULE__{} = document, line_number) do + case fetch_line_at(document, line_number) do + {:ok, line(text: text)} -> {:ok, text} + _ -> :error + end + end + + @doc """ + Get the `Engine>Document.Line` at the given index using `fetch` semantics. + + This function is of limited utility, you probably want `fetch_text_at/2` instead. + """ + @spec fetch_line_at(t, version()) :: {:ok, Line.t()} | :error + def fetch_line_at(%__MODULE__{} = document, line_number) do + case Lines.fetch_line(document.lines, line_number) do + {:ok, line} -> {:ok, line} + _ -> :error + end + end + + @doc """ + Returns a fragment defined by the from and to arguments + + Builds a string that represents the text of the document from the two positions given. + The from position, defaults to `:beginning` meaning the start of the document. + Positions can be a `Document.Position.t` or anything that will convert to a position using + `Engine.Convertible.to_native/2`. + """ + @spec fragment(t, fragment_position() | :beginning, fragment_position()) :: String.t() + @spec fragment(t, fragment_position()) :: String.t() + def fragment(%__MODULE__{} = document, from \\ :beginning, to) do + line_count = size(document) + from_pos = convert_fragment_position(document, from) + to_pos = convert_fragment_position(document, to) + + from_line = Math.clamp(from_pos.line, document.lines.starting_index, line_count) + to_line = Math.clamp(to_pos.line, from_line, line_count + 1) + + # source code positions are 1 based, but string slices are zero-based. Need an ad-hoc conversion + # here. + from_character = from_pos.character - 1 + to_character = to_pos.character - 1 + + line_range = from_line..to_line + + line_range + |> Enum.reduce([], fn line_number, acc -> + to_append = + case fetch_line_at(document, line_number) do + {:ok, line(text: text, ending: ending)} -> + line_text = text <> ending + + cond do + line_number == from_line and line_number == to_line -> + slice_length = to_character - from_character + String.slice(line_text, from_character, slice_length) + + line_number == from_line -> + slice_length = String.length(line_text) - from_character + String.slice(line_text, from_character, slice_length) + + line_number == to_line -> + String.slice(line_text, 0, to_character) + + true -> + line_text + end + + :error -> + [] + end + + [acc, to_append] + end) + |> IO.iodata_to_binary() + end + + @doc false + @spec apply_content_changes(t, version(), [Convertible.t() | nil]) :: + {:ok, t} | change_application_error() + def apply_content_changes(%__MODULE__{version: current_version}, new_version, _) + when new_version <= current_version do + {:error, :invalid_version} + end + + def apply_content_changes(%__MODULE__{} = document, _, []) do + {:ok, document} + end + + def apply_content_changes(%__MODULE__{} = document, version, changes) when is_list(changes) do + result = + Enum.reduce_while(changes, document, fn + nil, document -> + {:cont, document} + + change, document -> + case apply_change(document, change) do + {:ok, new_document} -> + {:cont, new_document} + + error -> + {:halt, error} + end + end) + + case result do + %__MODULE__{} = document -> + document = mark_dirty(%__MODULE__{document | version: version}) + + {:ok, document} + + error -> + error + end + end + + @doc """ + Converts a document to a string + + This function converts the given document back into a string, with line endings + preserved. + """ + def to_string(%__MODULE__{} = document) do + document + |> to_iodata() + |> IO.iodata_to_binary() + end + + @spec language_id_from_path(Engine.path()) :: String.t() + defp language_id_from_path(path) do + case Path.extname(path) do + ".ex" -> + "elixir" + + ".exs" -> + "elixir-script" + + ".eex" -> + "eex" + + ".heex" -> + "phoenix-heex" + + extension -> + Logger.warning("can't infer lang ID for #{path}, ext: #{extension}.") + + "unsupported (#{extension})" + end + end + + # private + + defp line_count(%__MODULE__{} = document) do + Lines.size(document.lines) + end + + defp apply_change( + %__MODULE__{} = document, + %Range{start: %Position{} = start_pos, end: %Position{} = end_pos}, + new_text + ) do + start_line = start_pos.line + + new_lines_iodata = + cond do + start_line > line_count(document) -> + append_to_end(document, new_text) + + start_line < 1 -> + prepend_to_beginning(document, new_text) + + true -> + apply_valid_edits(document, new_text, start_pos, end_pos) + end + + new_document = + new_lines_iodata + |> IO.iodata_to_binary() + |> Lines.new() + + {:ok, %__MODULE__{document | lines: new_document}} + end + + defp apply_change(%__MODULE__{} = document, %Edit{range: nil} = edit) do + {:ok, %__MODULE__{document | lines: Lines.new(edit.text)}} + end + + defp apply_change(%__MODULE__{} = document, %Edit{range: %Range{}} = edit) do + if valid_edit?(edit) do + apply_change(document, edit.range, edit.text) + else + {:error, {:invalid_range, edit.range}} + end + end + + defp apply_change(%__MODULE__{} = document, %{range: range, text: text}) do + with {:ok, native_range} <- Convertible.to_native(range, document) do + apply_change(document, Edit.new(text, native_range)) + end + end + + defp apply_change(%__MODULE__{} = document, convertable_edit) do + with {:ok, edit} <- Convertible.to_native(convertable_edit, document) do + apply_change(document, edit) + end + end + + defp valid_edit?(%Edit{ + range: %Range{start: %Position{} = start_pos, end: %Position{} = end_pos} + }) do + start_pos.line >= 0 and start_pos.character >= 0 and end_pos.line >= 0 and + end_pos.character >= 0 + end + + defp append_to_end(%__MODULE__{} = document, edit_text) do + [to_iodata(document), edit_text] + end + + defp prepend_to_beginning(%__MODULE__{} = document, edit_text) do + [edit_text, to_iodata(document)] + end + + defp apply_valid_edits(%__MODULE__{} = document, edit_text, start_pos, end_pos) do + Lines.reduce(document.lines, [], fn line() = line, acc -> + case edit_action(line, edit_text, start_pos, end_pos) do + :drop -> + acc + + {:append, io_data} -> + [acc, io_data] + end + end) + end + + defp edit_action(line() = line, edit_text, %Position{} = start_pos, %Position{} = end_pos) do + %Position{line: start_line, character: start_char} = start_pos + %Position{line: end_line, character: end_char} = end_pos + + line(line_number: line_number, text: text, ending: ending) = line + + cond do + line_number < start_line -> + {:append, [text, ending]} + + line_number > end_line -> + {:append, [text, ending]} + + line_number == start_line && line_number == end_line -> + prefix_text = utf8_prefix(line, start_char) + suffix_text = utf8_suffix(line, end_char) + {:append, [prefix_text, edit_text, suffix_text, ending]} + + line_number == start_line -> + prefix_text = utf8_prefix(line, start_char) + {:append, [prefix_text, edit_text]} + + line_number == end_line -> + suffix_text = utf8_suffix(line, end_char) + {:append, [suffix_text, ending]} + + true -> + :drop + end + end + + defp utf8_prefix(line(text: text), start_code_unit) do + length = max(0, start_code_unit - 1) + binary_part(text, 0, length) + end + + defp utf8_suffix(line(text: text), start_code_unit) do + byte_count = byte_size(text) + start_index = min(start_code_unit - 1, byte_count) + length = byte_count - start_index + + binary_part(text, start_index, length) + end + + defp to_iodata(%__MODULE__{} = document) do + Lines.to_iodata(document.lines) + end + + @spec convert_fragment_position(t, Position.t() | :beginning | Convertible.t()) :: Position.t() + defp convert_fragment_position(%__MODULE__{}, %Position{} = pos) do + pos + end + + defp convert_fragment_position(%__MODULE__{} = document, :beginning) do + Position.new(document, 1, 1) + end + + defp convert_fragment_position(%__MODULE__{} = document, convertible) do + {:ok, %Position{} = converted} = Convertible.to_native(convertible, document) + converted + end +end diff --git a/engine/lib/engine/document/changes.ex b/engine/lib/engine/document/changes.ex new file mode 100644 index 00000000..323389ad --- /dev/null +++ b/engine/lib/engine/document/changes.ex @@ -0,0 +1,31 @@ +defmodule Engine.Document.Changes do + @moduledoc """ + A `Engine.Document.Container` for text edits. + + This struct is helpful if you need to express one or several text edits in an LSP response. + It will convert cleanly into either a single `TextEdit` or a list of `TextEdit`s depending on + whether you passed a single edit or a list of edits. + + Using this struct allows efficient conversions at the language server border, as the document + doesn't have to be looked up (and possibly read off the filesystem) by the language server. + """ + defstruct [:document, :edits] + alias Engine.Document + + use Engine.StructAccess + + @type edits :: Document.Edit.t() | [Document.Edit.t()] + @type t :: %__MODULE__{ + document: Document.t(), + edits: edits + } + + @doc """ + Creates a new Changes struct given a document and edits. + + """ + @spec new(Document.t(), edits()) :: t() + def new(document, edits) do + %__MODULE__{document: document, edits: edits} + end +end diff --git a/engine/lib/engine/document/container.ex b/engine/lib/engine/document/container.ex new file mode 100644 index 00000000..6df7f32d --- /dev/null +++ b/engine/lib/engine/document/container.ex @@ -0,0 +1,49 @@ +defprotocol Engine.Document.Container do + @moduledoc """ + A protocol used to find relevant documents in structs + + When converting positions from lsp formats to native and vice versa, you need the + line of text from the relevant document. However, due to the nature of the protocol + structs, there isn't a single place where the document (or a reference) to the document + sits. This protocol allows generic access to the relevant document regardless of the + structure. + + Note: This protocol only needs to be implemented for structs that don't have a `document` + field, or don't have a `text_document` field with a `uri` sub-field. The following structs + would _not_ need an implementation: + + ``` + %MyStruct{document: %Engine.Document{}} + %MyStruct{text_document: %{uri: "file:///path/to/document.ex"}} + ``` + """ + alias Engine.Document + @fallback_to_any true + @type maybe_context_document :: Document.t() | nil + + @spec context_document(t, maybe_context_document()) :: maybe_context_document() + def context_document(t, parent_context_document) +end + +defimpl Engine.Document.Container, for: Any do + alias Engine.Document + + def context_document(%{document: %Document{} = document}, _) do + document + end + + def context_document(%{lsp: lsp_request}, parent_context_document) do + context_document(lsp_request, parent_context_document) + end + + def context_document(%{text_document: %{uri: uri}}, parent_context_document) do + case Document.Store.fetch(uri) do + {:ok, document} -> document + _ -> parent_context_document + end + end + + def context_document(_, parent_context_document) do + parent_context_document + end +end diff --git a/engine/lib/engine/document/edit.ex b/engine/lib/engine/document/edit.ex new file mode 100644 index 00000000..ccb52735 --- /dev/null +++ b/engine/lib/engine/document/edit.ex @@ -0,0 +1,35 @@ +defmodule Engine.Document.Edit do + @moduledoc """ + A change to a document + + A `Engine.Document.Edit` represents a single change to a document. It contains + the new text and a range where the edit applies. + """ + alias Engine.Document.Range + alias Engine.StructAccess + + defstruct [:text, :range] + + @type t :: %__MODULE__{ + text: String.t(), + range: Range.t() | nil + } + + use StructAccess + + @doc "Creates a new edit that replaces all text in the document" + @spec new(String.t(), Range.t() | nil) :: t + @spec new(String.t()) :: t + def new(text) when is_binary(text) do + %__MODULE__{text: text} + end + + @doc "Creates a new edit that replaces text in the given range" + def new(text, %Range{} = range) do + %__MODULE__{text: text, range: range} + end + + def new(text, nil) when is_binary(text) do + %__MODULE__{text: text} + end +end diff --git a/engine/lib/engine/document/line.ex b/engine/lib/engine/document/line.ex new file mode 100644 index 00000000..d70dd202 --- /dev/null +++ b/engine/lib/engine/document/line.ex @@ -0,0 +1,30 @@ +defmodule Engine.Document.Line do + @moduledoc ~S""" + A record representing a line of text in a document + + A line contains the following keys: + + `text`: The actual text of the line, without the line ending + + `ending`: The end of line character(s) can be `"\n"`, `"\r"` or `"\r\n"`. The original + line ending is preserved + + `line_number`: A zero-based line number + + `ascii?`: A boolean representing if this line consists of only ascii text. + """ + import Record + + @doc """ + Creates or matches a line of text + """ + defrecord :line, text: nil, ending: nil, line_number: 0, ascii?: true + + @type t :: + record(:line, + text: String.t(), + ending: String.t(), + line_number: non_neg_integer, + ascii?: boolean + ) +end diff --git a/engine/lib/engine/document/line_parser.ex b/engine/lib/engine/document/line_parser.ex new file mode 100644 index 00000000..5826d217 --- /dev/null +++ b/engine/lib/engine/document/line_parser.ex @@ -0,0 +1,109 @@ +defmodule Engine.Document.LineParser do + @moduledoc """ + A parser that parses a binary into `Engine.Document.Line` records. + + The approach taken by the parser is to first go through the binary to find out where + the lines break, what their endings are and if the line is ascii. As we go through the + binary, we store this information, and when we're done, go back and split up the binary + using `binary_slice`. This performs 3x faster than iterating through the binary and collecting + IOlists that represent each line. + + I determines if a line is ascii (and what it really means is utf8 ascii) by checking to see if + each byte is greater than 0 and less than 128. UTF-16 files won't be marked as ascii, which + allows us to skip a lot of byte conversions later in the process. + """ + import Engine.Document.Line + + # it's important that "\r\n" comes before \r here, otherwise the generated pattern + # matches won't match. + @endings ["\r\n", "\r", "\n"] + @max_ascii_character 127 + + @doc """ + Parses the text into lines + + Parses the given text into lines, and uses `starting_index` as the first line's line number. + Passing 0 as starting_index yields a zero-based collection, while passing 1 yields a 1-based + collection. + """ + def parse(text, starting_index) do + text + |> traverse(starting_index) + |> Enum.reduce([], fn index, acc -> [extract_line(text, index) | acc] end) + end + + defp extract_line(text, {line_number, start, stop, is_ascii?, ending}) do + line_text = binary_part(text, start, stop) + line(line_number: line_number, text: line_text, ascii?: is_ascii?, ending: ending) + end + + defp traverse(text, starting_index) do + traverse(text, 0, starting_index, 0, true, []) + end + + for ending <- @endings, + ending_length = byte_size(ending) do + defp traverse( + <>, + current_index, + line_number, + line_start_index, + is_ascii?, + acc + ) do + line_length = current_index - line_start_index + line_index = {line_number, line_start_index, line_length, is_ascii?, unquote(ending)} + [line_index | acc] + end + + defp traverse( + <>, + current_index, + line_number, + line_start_index, + is_ascii?, + acc + ) do + line_length = current_index - line_start_index + + acc = [{line_number, line_start_index, line_length, is_ascii?, unquote(ending)} | acc] + next_index = current_index + unquote(ending_length) + traverse(rest, next_index, line_number + 1, next_index, is_ascii?, acc) + end + end + + defp traverse( + <>, + current_index, + line_number, + line_start_index, + is_ascii?, + acc + ) do + # Note, this heuristic assumes the NUL character won't occur in elixir source files. + # if this isn't true, then we need a better heuristic for detecting utf16 text. + is_still_ascii? = is_ascii? and c <= @max_ascii_character and c > 0 + + traverse( + rest, + current_index + 1, + line_number, + line_start_index, + is_still_ascii?, + acc + ) + end + + defp traverse(<<>>, same_index, _line_number, same_index, _is_ascii, acc) do + # this is a line at the end of the document with no content + # I'm choosing not to represent it as a line to simplify things + # and to make the line count what we expect + acc + end + + defp traverse(<<>>, current_index, line_number, line_start_index, is_ascii?, acc) do + # file doesn't end with a newline + line_length = current_index - line_start_index + [{line_number, line_start_index, line_length, is_ascii?, ""} | acc] + end +end diff --git a/engine/lib/engine/document/lines.ex b/engine/lib/engine/document/lines.ex new file mode 100644 index 00000000..f023e21d --- /dev/null +++ b/engine/lib/engine/document/lines.ex @@ -0,0 +1,175 @@ +defmodule Engine.Document.Lines do + @moduledoc """ + A hyper-optimized, line-based backing store for text documents + """ + alias Engine.Document.Line + alias Engine.Document.LineParser + + use Engine.StructAccess + import Line + + @default_starting_index 1 + + defstruct lines: nil, starting_index: @default_starting_index + + @type t :: %__MODULE__{} + + @doc """ + Create a new line store with the given text at the given starting index + """ + @spec new(String.t(), non_neg_integer) :: t + def new(text, starting_index \\ @default_starting_index) do + lines = + text + |> LineParser.parse(starting_index) + |> List.to_tuple() + + %__MODULE__{lines: lines, starting_index: starting_index} + end + + @doc """ + Turnss a line store into an iolist + """ + @spec to_iodata(t) :: iodata() + def to_iodata(%__MODULE__{} = document) do + reduce(document, [], fn line(text: text, ending: ending), acc -> + [acc | [text | ending]] + end) + end + + @doc """ + Turns a line store into a string + """ + def to_string(%__MODULE__{} = document) do + document + |> to_iodata() + |> IO.iodata_to_binary() + end + + @doc """ + Returns the number of lines in the line store + """ + def size(%__MODULE__{} = document) do + tuple_size(document.lines) + end + + @doc """ + Gets the current line with the given index using fetch semantics + """ + def fetch_line(%__MODULE__{lines: lines, starting_index: starting_index}, index) + when index - starting_index >= tuple_size(lines) or index < starting_index do + :error + end + + def fetch_line(%__MODULE__{lines: {}}, _) do + :error + end + + def fetch_line(%__MODULE__{} = document, index) when is_integer(index) do + case elem(document.lines, index - document.starting_index) do + line() = line -> {:ok, line} + _ -> :error + end + end + + @doc false + def reduce(%__MODULE__{} = document, initial, reducer_fn) do + size = size(document) + + if size == 0 do + initial + else + Enum.reduce(0..(size - 1), initial, fn index, acc -> + document.lines + |> elem(index) + |> reducer_fn.(acc) + end) + end + end +end + +defimpl Inspect, for: Engine.Document.Lines do + alias Engine.Document.Lines + alias Engine.Document.Line + + import Inspect.Algebra + import Line + + def inspect(%Lines{lines: {}}) do + concat([empty(), "%Lines"]) + end + + def inspect(document, opts) do + document_body = + case Lines.fetch_line(document, 1) do + {:ok, line(text: text)} -> + concat(empty(), to_doc(text <> "...", opts)) + + :error -> + " empty " + end + + line_or_lines = + if Lines.size(document) == 1 do + "line" + else + "lines" + end + + concat([ + empty(), + "%Lines<", + document_body, + "(", + space( + to_doc(Lines.size(document), opts), + line_or_lines + ), + ")>" + ]) + end +end + +defimpl Enumerable, for: Engine.Document.Lines do + alias Engine.Document.Lines + + def count(%Lines{} = document) do + {:ok, Lines.size(document)} + end + + def member?(%Lines{}, _) do + {:error, Lines} + end + + def reduce(%Lines{} = document, acc, fun) do + tuple_reduce({0, tuple_size(document.lines), document.lines}, acc, fun) + end + + def slice(%Lines{} = document) do + {:ok, Lines.size(document), fn start, len -> do_slice(document, start, len) end} + end + + defp do_slice(%Lines{} = document, start, 1) do + [elem(document.lines, start)] + end + + defp do_slice(%Lines{} = document, start, length) do + Enum.map(start..(start + length - 1), &elem(document.lines, &1)) + end + + defp tuple_reduce(_, {:halt, acc}, _fun) do + {:halted, acc} + end + + defp tuple_reduce(current_state, {:suspend, acc}, fun) do + {:suspended, acc, &tuple_reduce(current_state, &1, fun)} + end + + defp tuple_reduce({same, same, _}, {:cont, acc}, _) do + {:done, acc} + end + + defp tuple_reduce({index, size, tuple}, {:cont, acc}, fun) do + tuple_reduce({index + 1, size, tuple}, fun.(elem(tuple, index), acc), fun) + end +end diff --git a/engine/lib/engine/document/location.ex b/engine/lib/engine/document/location.ex new file mode 100644 index 00000000..a0aa4c63 --- /dev/null +++ b/engine/lib/engine/document/location.ex @@ -0,0 +1,41 @@ +defmodule Engine.Document.Location do + @moduledoc """ + A location in a document + + One of the fundamental LSP structures, this represents a subset of text in a document. + The location is bounded by the given range, and the document can be given as a `Engine.Document` + struct, or a uri referencing the document + """ + alias Engine.Document + alias Engine.Document.Range + + defstruct [:range, :document, :uri] + + @type t :: %__MODULE__{ + range: Range.t(), + document: Document.t() | nil, + uri: Engine.uri() + } + use Engine.StructAccess + + @spec new(Range.t(), Document.t() | String.t()) :: t() + def new(%Range{} = range, %Document{} = document) do + %__MODULE__{range: range, document: document, uri: document.uri} + end + + def new(%Range{} = range, uri) when is_binary(uri) do + %__MODULE__{range: range, uri: uri} + end + + def uri(%__MODULE__{document: %Document{} = document}) do + document.uri + end + + @doc """ + Returns the location document's uri. + """ + @spec uri(t) :: Engine.uri() + def uri(%__MODULE__{} = location) do + location.uri + end +end diff --git a/engine/lib/engine/document/path.ex b/engine/lib/engine/document/path.ex new file mode 100644 index 00000000..f943298b --- /dev/null +++ b/engine/lib/engine/document/path.ex @@ -0,0 +1,148 @@ +defmodule Engine.Document.Path do + @moduledoc """ + A collection of functions dealing with converting filesystem paths to URIs and back + """ + @file_scheme "file" + + @type uri_or_path :: Engine.uri() | Engine.path() + + @doc """ + Given a uri or a path, either return the uri unmodified or converts the path to a uri + """ + @spec ensure_uri(uri_or_path()) :: Engine.uri() + def ensure_uri("file://" <> _ = uri), do: uri + + def ensure_uri("untitled:" <> _ = uri), do: uri + + def ensure_uri(path), do: to_uri(path) + + @doc """ + Given a uri or a path, either return the path unmodified or converts the uri to a path + """ + @spec ensure_path(uri_or_path()) :: Engine.path() + def ensure_path("file://" <> _ = uri), do: from_uri(uri) + + def ensure_path(path) when is_binary(path), do: path + + @doc """ + Returns path from URI in a way that handles windows file:///c%3A/... URLs correctly + """ + def from_uri(%URI{scheme: @file_scheme, path: nil}) do + # treat no path as root path + convert_separators_to_native("/") + end + + def from_uri(%URI{scheme: @file_scheme, path: path, authority: authority}) + when path != "" and authority not in ["", nil] do + # UNC path + convert_separators_to_native("//#{URI.decode(authority)}#{URI.decode(path)}") + end + + def from_uri(%URI{scheme: @file_scheme, path: path}) do + decoded_path = URI.decode(path) + + path = + if windows?() and String.match?(decoded_path, ~r/^\/[a-zA-Z]:/) do + # Windows drive letter path + # drop leading `/` and downcase drive letter + <<"/", letter::binary-size(1), path_rest::binary>> = decoded_path + "#{String.downcase(letter)}#{path_rest}" + else + decoded_path + end + + convert_separators_to_native(path) + end + + # `untitled:` URIs are used for unsaved files in vscode. + def from_uri(%URI{scheme: "untitled"} = uri) when uri.path !== nil do + URI.to_string(uri) + end + + def from_uri(%URI{scheme: scheme}) do + raise ArgumentError, message: "unsupported URI scheme #{inspect(scheme)}" + end + + def from_uri(uri) do + uri |> URI.parse() |> from_uri() + end + + def absolute_from_uri(uri) do + uri |> from_uri() |> Path.absname() + end + + @doc """ + Converts a path into a URI + """ + def to_uri(path) do + path = + path + |> Path.expand() + |> convert_separators_to_universal() + + {authority, path} = + case path do + "//" <> rest -> + # UNC path - extract authority + case String.split(rest, "/", parts: 2) do + [_] -> + # no path part, use root path + {rest, "/"} + + [authority, ""] -> + # empty path part, use root path + {authority, "/"} + + [authority, p] -> + {authority, "/" <> p} + end + + "/" <> _rest -> + {"", path} + + other -> + # treat as relative to root path + {"", "/" <> other} + end + + %URI{ + scheme: @file_scheme, + authority: authority |> URI.encode(), + # file system paths allow reserved URI characters that need to be escaped + # the exact rules are complicated but for simplicity we escape all reserved except `/` + # that's what https://github.com/microsoft/vscode-uri does + path: path |> URI.encode(&(&1 == ?/ or URI.char_unreserved?(&1))) + } + |> URI.to_string() + end + + defp convert_separators_to_native(path) do + if windows?() do + # convert path separators from URI to Windows + String.replace(path, ~r/\//, "\\") + else + path + end + end + + defp convert_separators_to_universal(path) do + if windows?() do + # convert path separators from Windows to URI + String.replace(path, ~r/\\/, "/") + else + path + end + end + + defp windows? do + case os_type() do + {:win32, _} -> true + _ -> false + end + end + + # this is here to be mocked in tests + defp os_type do + :os.type() + end +end diff --git a/engine/lib/engine/document/position.ex b/engine/lib/engine/document/position.ex new file mode 100644 index 00000000..b29f9d93 --- /dev/null +++ b/engine/lib/engine/document/position.ex @@ -0,0 +1,117 @@ +defmodule Engine.Document.Position do + @moduledoc """ + A position inside of a document + + This struct represents a cursor position inside a document, using one-based line and character + numbers. It's important to note that the position starts before the character given, so positions + are inclusive of the given character. + + Given the following line of text: + "Hello there, welcome to lexical" + + the position: `%Engine.Document.Position{line: 1, character: 1}` starts before the "H" in "Hello" + """ + + alias Engine.Document + alias Engine.Document.Lines + + defstruct [ + :line, + :character, + valid?: false, + context_line: nil, + document_line_count: 0, + starting_index: 1 + ] + + @type line :: non_neg_integer() + @type character :: non_neg_integer() + @type line_container :: Document.t() | Lines.t() + + @type t :: %__MODULE__{ + character: character(), + context_line: Document.Line.t() | nil, + document_line_count: non_neg_integer(), + line: line(), + starting_index: non_neg_integer(), + valid?: boolean() + } + + use Engine.StructAccess + + @spec new(line_container(), line(), character()) :: t + def new(%Document{} = document, line, character) + when is_number(line) and is_number(character) do + new(document.lines, line, character) + end + + def new(%Document.Lines{} = lines, line, character) + when is_number(line) and is_number(character) do + line_count = Document.Lines.size(lines) + starting_index = lines.starting_index + + case Lines.fetch_line(lines, line) do + {:ok, context_line} -> + %__MODULE__{ + character: character, + context_line: context_line, + document_line_count: line_count, + line: line, + starting_index: starting_index, + valid?: true + } + + :error -> + %__MODULE__{ + line: line, + character: character, + document_line_count: line_count, + starting_index: starting_index + } + end + end + + @doc """ + Compares two positions. + + Returns `:gt`, `:lt`, or `:eq` depending on the location of the first + position relative to the second. + """ + @spec compare(t | {line, character}, t | {line, character}) :: :lt | :eq | :gt + def compare(%__MODULE__{} = pos1, %__MODULE__{} = pos2) do + compare({pos1.line, pos1.character}, {pos2.line, pos2.character}) + end + + def compare(%__MODULE__{} = pos1, {_, _} = pos2) do + compare({pos1.line, pos1.character}, pos2) + end + + def compare({_, _} = pos1, %__MODULE__{} = pos2) do + compare(pos1, {pos2.line, pos2.character}) + end + + def compare({l1, c1} = first, {l2, c2} = second) + when is_integer(l1) and is_integer(c1) and is_integer(l2) and is_integer(c2) do + cond do + first < second -> :lt + first > second -> :gt + true -> :eq + end + end +end + +defimpl Inspect, for: Engine.Document.Position do + import Inspect.Algebra + + def inspect(nil, _), do: "nil" + + def inspect(pos, _) do + concat(["LxPos", to_string(pos)]) + end +end + +defimpl String.Chars, for: Engine.Document.Position do + def to_string(pos) do + "<<#{pos.line}, #{pos.character}>>" + end +end diff --git a/engine/lib/engine/document/range.ex b/engine/lib/engine/document/range.ex new file mode 100644 index 00000000..e47f3b92 --- /dev/null +++ b/engine/lib/engine/document/range.ex @@ -0,0 +1,65 @@ +defmodule Engine.Document.Range do + @moduledoc """ + A range in a document + + Note that ranges represent a cursor position, and so are inclusive of + lines, but exclusive of the end position. + + Note: To select an entire line, construct a range that runs from the + first character on the line to the first character on the next line. + + ``` + whole_line = + Range.new( + Position.new(doc, 1, 1), + Position.new(doc, 2, 1) + ) + ``` + """ + alias Engine.Document.Position + + defstruct start: nil, end: nil + + @type t :: %__MODULE__{ + start: Position.t(), + end: Position.t() + } + + use Engine.StructAccess + + @doc """ + Builds a new range. + """ + def new(%Position{} = start_pos, %Position{} = end_pos) do + %__MODULE__{start: start_pos, end: end_pos} + end + + @doc """ + Returns whether the range contains the given position. + """ + def contains?(%__MODULE__{} = range, %Position{} = position) do + %__MODULE__{start: start_pos, end: end_pos} = range + + cond do + position.line == start_pos.line and position.line == end_pos.line -> + position.character >= start_pos.character and position.character <= end_pos.character + + position.line == start_pos.line -> + position.character >= start_pos.character + + position.line == end_pos.line -> + position.character < end_pos.character + + true -> + position.line > start_pos.line and position.line < end_pos.line + end + end +end + +defimpl Inspect, for: Engine.Document.Range do + import Inspect.Algebra + + def inspect(range, _) do + concat(["LxRange[", to_string(range.start), "...", to_string(range.end), "]"]) + end +end diff --git a/engine/lib/engine/document/store.ex b/engine/lib/engine/document/store.ex new file mode 100644 index 00000000..2a233b07 --- /dev/null +++ b/engine/lib/engine/document/store.ex @@ -0,0 +1,423 @@ +defmodule Engine.Document.Store do + @moduledoc """ + Backing store for source file documents. + """ + + alias Engine.Document + alias Engine.ProcessCache + + use GenServer + + @type updater :: (Document.t() -> {:ok, Document.t()} | {:error, any()}) + + @type derivations :: [derivation] + @type derivation :: {derivation_key, derivation_fun} + @type derivation_key :: atom() + @type derivation_fun :: (Document.t() -> derived_value) + @type derived_value :: any() + + @type start_opts :: [start_opt] + @type start_opt :: {:derive, derivations} + + defmodule State do + @moduledoc false + + alias Engine.Document + alias Engine.Document.Store + + require Logger + + import Record + + defstruct open: %{}, temporary_open_refs: %{}, derivation_funs: %{} + + @type t :: %__MODULE__{} + + defrecord :open_doc, document: nil, derived: %{} + + def new(opts \\ []) do + {derivation_funs, invalid} = + opts + |> Keyword.validate!(derive: []) + |> Keyword.fetch!(:derive) + |> Enum.split_with(fn + {atom, fun} when is_atom(atom) and is_function(fun, 1) -> true + _ -> false + end) + + if invalid != [] do + raise ArgumentError, "invalid derive: #{inspect(invalid)}" + end + + %__MODULE__{derivation_funs: Map.new(derivation_funs)} + end + + @spec fetch(t, Engine.uri()) :: {:ok, Document.t(), t} | {:error, :not_open} + def fetch(%__MODULE__{} = store, uri) do + case store.open do + %{^uri => open_doc(document: document)} -> {:ok, document, store} + _ -> {:error, :not_open} + end + end + + @spec fetch(t, Engine.uri(), Store.derivation_key()) :: + {:ok, Document.t(), Store.derived_value(), t} | {:error, :not_open} + def fetch(%__MODULE__{} = store, uri, key) do + case store.open do + %{^uri => open_doc(document: document, derived: %{^key => derivation})} -> + {:ok, document, derivation, store} + + %{^uri => open_doc(document: document, derived: derived)} -> + derivation = derive(store, key, document) + derived = Map.put(derived, key, derivation) + store = put_open_doc(store, document, derived) + {:ok, document, derivation, store} + + _ -> + {:error, :not_open} + end + end + + @spec save(t, Engine.uri()) :: {:ok, t} | {:error, :not_open} + def save(%__MODULE__{} = store, uri) do + case store.open do + %{^uri => open_doc(document: document, derived: derived)} -> + document = Document.mark_clean(document) + store = put_open_doc(store, document, derived) + {:ok, store} + + _ -> + {:error, :not_open} + end + end + + @spec open(t, Engine.uri(), String.t(), pos_integer(), String.t()) :: + {:ok, t} | {:error, :already_open} + def open(%__MODULE__{temporary_open_refs: refs} = store, uri, text, version, language_id) + when is_map_key(refs, uri) do + {_, store} = + store + |> maybe_cancel_ref(uri) + |> pop_open_doc(uri) + + open(store, uri, text, version, language_id) + end + + def open(%__MODULE__{} = store, uri, text, version, language_id) do + case store.open do + %{^uri => _} -> + {:error, :already_open} + + _ -> + document = Document.new(uri, text, version, language_id) + store = put_open_doc(store, document) + {:ok, store} + end + end + + @spec open?(t, Engine.uri()) :: boolean + def open?(%__MODULE__{} = store, uri) do + Map.has_key?(store.open, uri) + end + + @spec close(t, Engine.uri()) :: {:ok, t} | {:error, :not_open} + def close(%__MODULE__{} = store, uri) do + case pop_open_doc(store, uri) do + {nil, _} -> + {:error, :not_open} + + {_, store} -> + {:ok, maybe_cancel_ref(store, uri)} + end + end + + @spec get_and_update(t, Engine.uri(), Store.updater()) :: + {:ok, Document.t(), t} | {:error, any()} + def get_and_update(%__MODULE__{} = store, uri, updater_fn) do + with {:ok, open_doc(document: document)} <- Map.fetch(store.open, uri), + {:ok, document} <- updater_fn.(document) do + {:ok, document, put_open_doc(store, document)} + else + error -> + normalize_error(error) + end + end + + @spec update(t, Engine.uri(), Store.updater()) :: {:ok, t} | {:error, any()} + def update(%__MODULE__{} = store, uri, updater_fn) do + with {:ok, _, store} <- get_and_update(store, uri, updater_fn) do + {:ok, store} + end + end + + @spec open_temporarily(t, Engine.uri() | Path.t(), timeout()) :: + {:ok, Document.t(), t} | {:error, term()} + def open_temporarily(%__MODULE__{} = store, path_or_uri, timeout) do + uri = Document.Path.ensure_uri(path_or_uri) + path = Document.Path.ensure_path(path_or_uri) + + with {:ok, contents} <- File.read(path) do + document = Document.new(uri, contents, 0) + ref = schedule_unload(uri, timeout) + + new_store = + store + |> maybe_cancel_ref(uri) + |> put_ref(uri, ref) + |> put_open_doc(document) + + {:ok, document, new_store} + end + end + + @spec extend_timeout(t, Engine.uri(), timeout()) :: t + def extend_timeout(%__MODULE__{} = store, uri, timeout) do + case store.temporary_open_refs do + %{^uri => ref} -> + Process.cancel_timer(ref) + new_ref = schedule_unload(uri, timeout) + put_ref(store, uri, new_ref) + + _ -> + store + end + end + + @spec unload(t, Engine.uri()) :: t + def unload(%__MODULE__{} = store, uri) do + {_, store} = pop_open_doc(store, uri) + maybe_cancel_ref(store, uri) + end + + defp put_open_doc(%__MODULE__{} = store, %Document{} = document, derived \\ %{}) do + put_in(store.open[document.uri], open_doc(document: document, derived: derived)) + end + + defp pop_open_doc(%__MODULE__{} = store, uri) do + case Map.pop(store.open, uri) do + {open_doc() = doc, open} -> {doc, %__MODULE__{store | open: open}} + {nil, _} -> {nil, store} + end + end + + defp put_ref(%__MODULE__{} = store, uri, ref) do + put_in(store.temporary_open_refs[uri], ref) + end + + defp maybe_cancel_ref(%__MODULE__{} = store, uri) do + case pop_in(store.temporary_open_refs[uri]) do + {ref, store} when is_reference(ref) -> + Process.cancel_timer(ref) + store + + _ -> + store + end + end + + defp schedule_unload(uri, timeout) do + Process.send_after(self(), {:unload, uri}, timeout) + end + + defp normalize_error(:error), do: {:error, :not_open} + defp normalize_error(e), do: e + + defp derive(%__MODULE__{} = store, key, document) do + case store.derivation_funs do + %{^key => fun} -> + fun.(document) + + _ -> + known = Map.keys(store.derivation_funs) + + raise ArgumentError, + "No derivation for #{inspect(key)}, expected one of #{inspect(known)}" + end + end + end + + @spec fetch(Engine.uri()) :: {:ok, Document.t()} | {:error, :not_open} + def fetch(uri) do + GenServer.call(name(), {:fetch, uri}) + end + + @spec fetch(Engine.uri(), derivation_key) :: + {:ok, Document.t(), derived_value} | {:error, :not_open} + def fetch(uri, key) do + GenServer.call(name(), {:fetch, uri, key}) + end + + @spec save(Engine.uri()) :: :ok | {:error, :not_open} + def save(uri) do + GenServer.call(name(), {:save, uri}) + end + + @spec open?(Engine.uri()) :: boolean() + def open?(uri) do + GenServer.call(name(), {:open?, uri}) + end + + @spec open(Engine.uri(), String.t(), String.t(), pos_integer() | nil) :: + :ok | {:error, :already_open} + def open(uri, text, version, language_id \\ nil) do + GenServer.call(name(), {:open, uri, text, version, language_id}) + end + + @spec open_temporary(Engine.uri() | Path.t()) :: + {:ok, Document.t()} | {:error, term()} + + @spec open_temporary(Engine.uri() | Path.t(), timeout()) :: + {:ok, Document.t()} | {:error, term()} + def open_temporary(uri, timeout \\ 5000) when is_binary(uri) do + ProcessCache.trans(uri, 50, fn -> + GenServer.call(name(), {:open_temporarily, uri, timeout}) + end) + end + + @spec close(Engine.uri()) :: :ok | {:error, :not_open} + def close(uri) do + GenServer.call(name(), {:close, uri}) + end + + @spec get_and_update(Engine.uri(), updater) :: {:ok, Document.t()} | {:error, any()} + def get_and_update(uri, update_fn) do + GenServer.call(name(), {:get_and_update, uri, update_fn}) + end + + @spec update(Engine.uri(), updater) :: :ok | {:error, any()} + def update(uri, update_fn) do + GenServer.call(name(), {:update, uri, update_fn}) + end + + @spec start_link(start_opts) :: GenServer.on_start() + def start_link(opts) do + GenServer.start_link(__MODULE__, opts, name: name()) + end + + @impl GenServer + def init(opts) do + {:ok, State.new(opts)} + end + + @impl GenServer + def handle_call({:save, uri}, _from, %State{} = state) do + {reply, new_state} = + case State.save(state, uri) do + {:ok, _} = success -> success + error -> {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:open, uri, text, version, language_id}, _from, %State{} = state) do + {reply, new_state} = + case State.open(state, uri, text, version, language_id) do + {:ok, _} = success -> success + error -> {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:open?, uri}, _from, %State{} = state) do + reply = State.open?(state, uri) + {:reply, reply, state} + end + + def handle_call({:open_temporarily, uri, timeout_ms}, _, %State{} = state) do + {reply, new_state} = + with {:error, :not_open} <- State.fetch(state, uri), + {:ok, document, new_state} <- State.open_temporarily(state, uri, timeout_ms) do + {{:ok, document}, new_state} + else + {:ok, document, new_state} -> + {{:ok, document}, State.extend_timeout(new_state, uri, timeout_ms)} + + error -> + {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:fetch, uri}, _from, %State{} = state) do + {reply, new_state} = + case State.fetch(state, uri) do + {:ok, value, new_state} -> {{:ok, value}, new_state} + error -> {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:fetch, uri, key}, _from, %State{} = state) do + {reply, new_state} = + case State.fetch(state, uri, key) do + {:ok, value, derived_value, new_state} -> {{:ok, value, derived_value}, new_state} + error -> {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:close, uri}, _from, %State{} = state) do + {reply, new_state} = + case State.close(state, uri) do + {:ok, new_state} -> {:ok, new_state} + error -> {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:get_and_update, uri, update_fn}, _from, %State{} = state) do + {reply, new_state} = + case State.get_and_update(state, uri, update_fn) do + {:ok, updated_source, new_state} -> {{:ok, updated_source}, new_state} + error -> {error, state} + end + + {:reply, reply, new_state} + end + + def handle_call({:update, uri, updater_fn}, _, %State{} = state) do + {reply, new_state} = + case State.update(state, uri, updater_fn) do + {:ok, new_state} -> {:ok, new_state} + error -> {error, state} + end + + {:reply, reply, new_state} + end + + @impl GenServer + def handle_info({:unload, uri}, %State{} = state) do + {:noreply, State.unload(state, uri)} + end + + def set_entropy(entropy) do + :persistent_term.put(entropy_key(), entropy) + entropy + end + + def entropy do + case :persistent_term.get(entropy_key(), :undefined) do + :undefined -> + [:positive] + |> System.unique_integer() + |> set_entropy() + + entropy -> + entropy + end + end + + def name do + {:via, :global, {__MODULE__, entropy()}} + end + + defp entropy_key do + {__MODULE__, :entropy} + end +end diff --git a/engine/lib/engine.ex b/engine/lib/engine/engine.ex similarity index 97% rename from engine/lib/engine.ex rename to engine/lib/engine/engine.ex index 5b18f323..025a7f34 100644 --- a/engine/lib/engine.ex +++ b/engine/lib/engine/engine.ex @@ -5,7 +5,7 @@ defmodule Engine do context of the remote VM. """ - alias Lexical.Project + alias Engine.Project alias Engine.Api.Proxy alias Engine.CodeAction @@ -226,4 +226,10 @@ defmodule Engine do end) |> Enum.reject(&is_nil/1) end + + @typedoc "A string representation of a uri" + @type uri :: String.t() + + @typedoc "A string representation of a path on the filesystem" + @type path :: String.t() end diff --git a/engine/lib/engine/formats.ex b/engine/lib/engine/formats.ex new file mode 100644 index 00000000..c7d7dcd7 --- /dev/null +++ b/engine/lib/engine/formats.ex @@ -0,0 +1,109 @@ +defmodule Engine.Formats do + @moduledoc """ + A collection of formatting functions + """ + + @type unit :: :millisecond | :second + @type time_opt :: {:unit, unit} + @type time_opts :: [time_opt] + + @doc """ + Formats an elapsed time to either seconds or milliseconds + + Examples: + + ``` + Format.seconds(500, unit: :millisecond) + "0.5 seconds" + ``` + + ``` + Format.format(1500, unit: :millisecond) + "1.4 seconds" + ``` + + ``` + Format.format(1500) + "15 ms" + ``` + """ + @spec time(time :: non_neg_integer(), opts :: time_opts) :: String.t() + def time(time, opts \\ []) do + units = Keyword.get(opts, :unit, :microsecond) + millis = to_milliseconds(time, units) + + cond do + millis >= 1000 -> + "#{Float.round(millis / 1000, 1)} seconds" + + millis >= 1.0 -> + "#{trunc(millis)} ms" + + true -> + "#{millis} ms" + end + end + + @doc """ + Formats a name of a module + Both elixir and erlang modules will format like they appear in elixir source code. + + ``` + Format.format(MyModule) + "MyModule" + ``` + + ``` + Formats.module(Somewhat.Nested.Module) + "Somewhat.Nested.Module" + ``` + + ``` + Format.format(:erlang_module) + ":erlang_module" + ``` + """ + @spec module(atom()) :: String.t() + def module(module_name) when is_atom(module_name) do + string_name = Atom.to_string(module_name) + + if String.contains?(string_name, ".") do + case string_name do + "Elixir." <> rest -> rest + other -> other + end + else + # erlang module_name + ":#{string_name}" + end + end + + def module(module_name) when is_binary(module_name) do + module_name + end + + defp to_milliseconds(micros, :microsecond) do + micros / 1000 + end + + defp to_milliseconds(millis, :millisecond) do + millis + end + + def plural(count, singular, plural) do + case count do + 0 -> templatize(count, plural) + 1 -> templatize(count, singular) + _n -> templatize(count, plural) + end + end + + def mfa(module, function, arity) do + "#{module(module)}.#{function}/#{arity}" + end + + defp templatize(count, template) do + count_string = Integer.to_string(count) + String.replace(template, "${count}", count_string) + end +end diff --git a/engine/lib/engine/math.ex b/engine/lib/engine/math.ex new file mode 100644 index 00000000..b4d6612e --- /dev/null +++ b/engine/lib/engine/math.ex @@ -0,0 +1,19 @@ +defmodule Engine.Math do + @moduledoc """ + Utilities related to mathematical operations + """ + + @doc """ + Clamp the number between `min_number` and `max_number` + + If the first argument is less than `min_number`, then `min_number` is returned. + + If the number given in the first argument is greater than `max_number` then `max_number` is returned. + + Otherwise, the first argument is returned. + """ + def clamp(number, min_number, max_number) + when is_number(number) and is_number(min_number) and is_number(max_number) do + number |> max(min_number) |> min(max_number) + end +end diff --git a/engine/lib/engine/mix.ex b/engine/lib/engine/mix.ex index 9323a8f6..27e38f1a 100644 --- a/engine/lib/engine/mix.ex +++ b/engine/lib/engine/mix.ex @@ -1,5 +1,5 @@ defmodule Engine.Mix do - alias Lexical.Project + alias Engine.Project def in_project(fun) do if Engine.project_node?() do diff --git a/engine/lib/engine/plugin.ex b/engine/lib/engine/plugin.ex index a5f1e3fb..4cfc302e 100644 --- a/engine/lib/engine/plugin.ex +++ b/engine/lib/engine/plugin.ex @@ -1,6 +1,6 @@ defmodule Engine.Plugin do - alias Lexical.Document - alias Lexical.Project + alias Engine.Document + alias Engine.Project alias Engine.Api.Messages alias Engine.Plugin.Runner diff --git a/engine/lib/engine/plugin/discovery.ex b/engine/lib/engine/plugin/discovery.ex index 11e97ef6..0d1bece6 100644 --- a/engine/lib/engine/plugin/discovery.ex +++ b/engine/lib/engine/plugin/discovery.ex @@ -6,7 +6,7 @@ defmodule Engine.Plugin.Discovery do If a plugin is found, the app is then registered with the plugin system. If we're running in a namespaced build, we must apply the same namespace to the plugin's modules, or it - will be looking for structs like `Lexical.Document`, and be passed in structs like `LXRelease.Document`, + will be looking for structs like `Engine.Document`, and be passed in structs like `LXRelease.Document`, and the plugin will crash. """ @@ -16,7 +16,7 @@ defmodule Engine.Plugin.Discovery do require Logger - @namespaced_document_module [:Lexical, :Document] + @namespaced_document_module [:Engine, :Document] |> Module.concat() |> Namespace.Module.apply() diff --git a/engine/lib/engine/plugin/runner.ex b/engine/lib/engine/plugin/runner.ex index ebeffb57..b8abe4ed 100644 --- a/engine/lib/engine/plugin/runner.ex +++ b/engine/lib/engine/plugin/runner.ex @@ -1,8 +1,8 @@ defmodule Engine.Plugin.Runner do @moduledoc false - alias Lexical.Document - alias Lexical.Project + alias Engine.Document + alias Engine.Project alias Engine.Module.Loader alias Engine.Plugin.Runner diff --git a/engine/lib/engine/plugin/runner/coordinator.ex b/engine/lib/engine/plugin/runner/coordinator.ex index edd64aac..31bb371b 100644 --- a/engine/lib/engine/plugin/runner/coordinator.ex +++ b/engine/lib/engine/plugin/runner/coordinator.ex @@ -1,7 +1,7 @@ defmodule Engine.Plugin.Runner.Coordinator do @moduledoc false - alias Lexical.Formats + alias Engine.Formats alias Engine.Plugin.Runner.Coordinator.State require Logger diff --git a/engine/lib/engine/port.ex b/engine/lib/engine/port.ex index cd0c4280..6a19406f 100644 --- a/engine/lib/engine/port.ex +++ b/engine/lib/engine/port.ex @@ -3,7 +3,7 @@ defmodule Engine.Port do Utilities for launching ports in the context of a project """ - alias Lexical.Project + alias Engine.Project @type open_opt :: {:env, list()} diff --git a/engine/lib/engine/process_cache.ex b/engine/lib/engine/process_cache.ex new file mode 100644 index 00000000..80ad3a56 --- /dev/null +++ b/engine/lib/engine/process_cache.ex @@ -0,0 +1,116 @@ +defmodule Engine.ProcessCache do + @moduledoc """ + A simple cache with a timeout that lives in the process dictionary + """ + + defmodule Entry do + @moduledoc false + + defstruct [:value, :expiry] + + def new(value, timeout_ms) do + expiry_ts = now_ts() + timeout_ms + %__MODULE__{value: value, expiry: expiry_ts} + end + + def valid?(%__MODULE__{} = entry) do + now_ts() < entry.expiry + end + + defp now_ts do + System.os_time(:millisecond) + end + end + + @type key :: term() + @type fetch_result :: {:ok, term()} | :error + + @doc """ + Retrieves a value from the cache + If the value is not found, the default is returned + """ + @spec get(key()) :: term() | nil + @spec get(key(), term()) :: term() | nil + def get(key, default \\ nil) do + case fetch(key) do + {:ok, val} -> val + :error -> default + end + end + + @doc """ + Retrieves a value from the cache + If the value is not found, the default is returned + """ + @spec fetch(key()) :: fetch_result() + def fetch(key) do + case Process.get(key, :unset) do + %Entry{} = entry -> + if Entry.valid?(entry) do + {:ok, entry.value} + else + Process.delete(key) + :error + end + + :unset -> + :error + end + end + + def clear_keys do + keys() + |> MapSet.put(all_keys_key()) + |> Enum.each(&Process.delete/1) + end + + @doc """ + Retrieves and optionally sets a value in the cache. + + Trans looks up a value in the cache under key. If that value isn't + found, the compute_fn is then executed, and its return value is set + in the cache. The cached value will live in the cache for `timeout` + milliseconds + """ + def trans(key, timeout_ms \\ 5000, compute_fn) do + case fetch(key) do + :error -> + set(key, timeout_ms, compute_fn) + + {:ok, result} -> + result + end + end + + defmacro with_cleanup(do: block) do + quote do + try do + unquote(block) + after + unquote(__MODULE__).clear_keys() + end + end + end + + defp set(key, timeout_ms, compute_fn) do + value = compute_fn.() + + add_key(key) + Process.put(key, Entry.new(value, timeout_ms)) + + value + end + + defp add_key(key) do + updated_keys = MapSet.put(keys(), key) + Process.put(all_keys_key(), updated_keys) + end + + defp all_keys_key do + {__MODULE__, :all_keys} + end + + defp keys do + Process.get(all_keys_key(), MapSet.new()) + end +end diff --git a/engine/lib/engine/project.ex b/engine/lib/engine/project.ex new file mode 100644 index 00000000..901a50be --- /dev/null +++ b/engine/lib/engine/project.ex @@ -0,0 +1,324 @@ +defmodule Engine.Project do + @moduledoc """ + The representation of the current state of an elixir project. + + This struct contains all the information required to build a project and interrogate its configuration, + as well as business logic for how to change its attributes. + """ + alias Engine.Document + + defstruct root_uri: nil, + mix_exs_uri: nil, + mix_project?: false, + mix_env: nil, + mix_target: nil, + env_variables: %{}, + project_module: nil, + entropy: 1 + + @type message :: String.t() + @type restart_notification :: {:restart, Logger.level(), String.t()} + @type t :: %__MODULE__{ + root_uri: Engine.uri() | nil, + mix_exs_uri: Engine.uri() | nil, + entropy: non_neg_integer() + # mix_env: atom(), + # mix_target: atom(), + # env_variables: %{String.t() => String.t()} + } + @type error_with_message :: {:error, message} + + @workspace_directory_name ".lexical" + + # Public + @spec new(Engine.uri()) :: t + def new(root_uri) do + entropy = :rand.uniform(65_536) + + %__MODULE__{entropy: entropy} + |> maybe_set_root_uri(root_uri) + |> maybe_set_mix_exs_uri() + end + + @spec set_project_module(t(), module() | nil) :: t() + def set_project_module(%__MODULE__{} = project, nil) do + project + end + + def set_project_module(%__MODULE__{} = project, module) when is_atom(module) do + %__MODULE__{project | project_module: module} + end + + @doc """ + Retrieves the name of the project + """ + @spec name(t) :: String.t() + + def name(%__MODULE__{} = project) do + sanitized = + project + |> folder_name() + |> String.replace(~r/[^a-zA-Z0-9_]/, "_") + + # This might be a litte verbose, but this code is hot. + case sanitized do + <> when c in ?a..?z -> + sanitized + + <> when c in ?A..?Z -> + String.downcase("#{[c]}") <> rest + + other -> + "p_#{other}" + end + end + + @doc """ + The project node's name + """ + def node_name(%__MODULE__{} = project) do + :"project-#{name(project)}-#{entropy(project)}@127.0.0.1" + end + + def entropy(%__MODULE__{} = project) do + project.entropy + end + + def config(%__MODULE__{} = project) do + config_key = {__MODULE__, name(project), :config} + + case :persistent_term.get(config_key, :not_found) do + :not_found -> + config = project.project_module.project() + :persistent_term.put(config_key, config) + config + + config -> + config + end + end + + @doc """ + Returns the the name definied in the `project/0` of mix.exs file + """ + def display_name(%__MODULE__{} = project) do + case config(project) do + [] -> + folder_name(project) + + config -> + Keyword.get(config, :name, folder_name(project)) + end + end + + @doc """ + Retrieves the name of the project as an atom + """ + @spec atom_name(t) :: atom + def atom_name(%__MODULE__{project_module: nil} = project) do + project + |> name() + |> String.to_atom() + end + + def atom_name(%__MODULE__{} = project) do + project.project_module + end + + @doc """ + Returns the full path of the project's root directory + """ + @spec root_path(t) :: Path.t() | nil + def root_path(%__MODULE__{root_uri: nil}) do + nil + end + + def root_path(%__MODULE__{} = project) do + Document.Path.from_uri(project.root_uri) + end + + @spec project_path(t) :: Path.t() | nil + def project_path(%__MODULE__{root_uri: nil}) do + nil + end + + def project_path(%__MODULE__{} = project) do + Document.Path.from_uri(project.root_uri) + end + + @doc """ + Returns the full path to the project's mix.exs file + """ + @spec mix_exs_path(t) :: Path.t() | nil + def mix_exs_path(%__MODULE__{mix_exs_uri: nil}) do + nil + end + + def mix_exs_path(%__MODULE__{mix_exs_uri: mix_exs_uri}) do + Document.Path.from_uri(mix_exs_uri) + end + + @spec change_environment_variables(t, map() | nil) :: + {:ok, t} | error_with_message() | restart_notification() + def change_environment_variables(%__MODULE__{} = project, environment_variables) do + set_env_vars(project, environment_variables) + end + + @doc """ + Returns the full path to the project's lexical workspace directory + + Engine maintains a workspace directory in project it konws about, and places various + artifacts there. This function returns the full path to that directory + """ + @spec workspace_path(t) :: String.t() + def workspace_path(%__MODULE__{} = project) do + project + |> root_path() + |> Path.join(@workspace_directory_name) + end + + @doc """ + Returns the full path to a file in lexical's workspace directory + """ + @spec workspace_path(t, String.t() | [String.t()]) :: String.t() + def workspace_path(%__MODULE__{} = project, relative_path) when is_binary(relative_path) do + workspace_path(project, [relative_path]) + end + + def workspace_path(%__MODULE__{} = project, relative_path) when is_list(relative_path) do + Path.join([workspace_path(project) | relative_path]) + end + + @doc """ + Returns the full path to the directory where lexical puts build artifacts + """ + def build_path(%__MODULE__{} = project) do + project + |> workspace_path() + |> Path.join("build") + end + + @doc """ + Creates and initializes lexical's workspace directory if it doesn't already exist + """ + def ensure_workspace(%__MODULE__{} = project) do + with :ok <- ensure_workspace_directory(project) do + ensure_git_ignore(project) + end + end + + defp ensure_workspace_directory(project) do + workspace_path = workspace_path(project) + + cond do + File.exists?(workspace_path) and File.dir?(workspace_path) -> + :ok + + File.exists?(workspace_path) -> + :ok = File.rm(workspace_path) + :ok = File.mkdir_p(workspace_path) + + true -> + :ok = File.mkdir(workspace_path) + end + end + + defp ensure_git_ignore(project) do + contents = """ + * + """ + + path = workspace_path(project, ".gitignore") + + if File.exists?(path) do + :ok + else + File.write(path, contents) + end + end + + defp maybe_set_root_uri(%__MODULE__{} = project, nil), + do: %__MODULE__{project | root_uri: nil} + + defp maybe_set_root_uri(%__MODULE__{} = project, "file://" <> _ = root_uri) do + root_path = + root_uri + |> Document.Path.absolute_from_uri() + |> Path.expand() + + if File.exists?(root_path) do + expanded_uri = Document.Path.to_uri(root_path) + %__MODULE__{project | root_uri: expanded_uri} + else + project + end + end + + defp maybe_set_mix_exs_uri(%__MODULE__{} = project) do + possible_mix_exs_path = + project + |> root_path() + |> find_mix_exs_path() + + if mix_exs_exists?(possible_mix_exs_path) do + %__MODULE__{ + project + | mix_exs_uri: Document.Path.to_uri(possible_mix_exs_path), + mix_project?: true + } + else + project + end + end + + # Project Path + + # Environment variables + + def set_env_vars(%__MODULE__{} = old_project, %{} = env_vars) do + case {old_project.env_variables, env_vars} do + {nil, vars} when map_size(vars) == 0 -> + {:ok, %__MODULE__{old_project | env_variables: vars}} + + {nil, new_vars} -> + System.put_env(new_vars) + {:ok, %__MODULE__{old_project | env_variables: new_vars}} + + {same, same} -> + {:ok, old_project} + + _ -> + {:restart, :warning, "Environment variables have changed. Engine needs to restart"} + end + end + + def set_env_vars(%__MODULE__{} = old_project, _) do + {:ok, old_project} + end + + defp find_mix_exs_path(nil) do + System.get_env("MIX_EXS") + end + + defp find_mix_exs_path(project_directory) do + case System.get_env("MIX_EXS") do + nil -> + Path.join(project_directory, "mix.exs") + + mix_exs -> + mix_exs + end + end + + defp mix_exs_exists?(nil), do: false + + defp mix_exs_exists?(mix_exs_path) do + File.exists?(mix_exs_path) + end + + defp folder_name(project) do + project + |> root_path() + |> Path.basename() + end +end diff --git a/engine/lib/engine/project_node.ex b/engine/lib/engine/project_node.ex index 2da921fc..7e325b99 100644 --- a/engine/lib/engine/project_node.ex +++ b/engine/lib/engine/project_node.ex @@ -1,5 +1,5 @@ defmodule Engine.ProjectNode do - alias Lexical.Project + alias Engine.Project require Logger @@ -104,7 +104,7 @@ defmodule Engine.ProjectNode do end end - alias Lexical.Document + alias Engine.Document alias Engine.ProjectNodeSupervisor use GenServer diff --git a/engine/lib/engine/project_node_supervisor.ex b/engine/lib/engine/project_node_supervisor.ex index b8a89098..5efcd835 100644 --- a/engine/lib/engine/project_node_supervisor.ex +++ b/engine/lib/engine/project_node_supervisor.ex @@ -1,5 +1,5 @@ defmodule Engine.ProjectNodeSupervisor do - alias Lexical.Project + alias Engine.Project alias Engine.ProjectNode use DynamicSupervisor diff --git a/engine/lib/engine/search/fuzzy.ex b/engine/lib/engine/search/fuzzy.ex index 0d768e27..ed5ad4ba 100644 --- a/engine/lib/engine/search/fuzzy.ex +++ b/engine/lib/engine/search/fuzzy.ex @@ -11,7 +11,7 @@ defmodule Engine.Search.Fuzzy do returned. """ - alias Lexical.Project + alias Engine.Project alias Engine.Search.Fuzzy.Scorer alias Engine.Search.Indexer.Entry @@ -289,7 +289,7 @@ defmodule Engine.Search.Fuzzy do end defp stringify(mapped(type: :module, subject: module_name)) do - Lexical.Formats.module(module_name) + Engine.Formats.module(module_name) end defp stringify(mapped(subject: string)) when is_binary(string) do @@ -307,10 +307,10 @@ defmodule Engine.Search.Fuzzy do defp stringify(atom) when is_atom(atom) do cond do function_exported?(atom, :__info__, 1) -> - Lexical.Formats.module(atom) + Engine.Formats.module(atom) function_exported?(atom, :module_info, 0) -> - Lexical.Formats.module(atom) + Engine.Formats.module(atom) true -> inspect(atom) diff --git a/engine/lib/engine/search/indexer.ex b/engine/lib/engine/search/indexer.ex index 543674f1..f1cf8bee 100644 --- a/engine/lib/engine/search/indexer.ex +++ b/engine/lib/engine/search/indexer.ex @@ -1,7 +1,7 @@ defmodule Engine.Search.Indexer do - alias Lexical.Identifier - alias Lexical.ProcessCache - alias Lexical.Project + alias Engine.Identifier + alias Engine.ProcessCache + alias Engine.Project alias Engine.Progress alias Engine.Search.Indexer diff --git a/engine/lib/engine/search/indexer/entry.ex b/engine/lib/engine/search/indexer/entry.ex index 91495127..8363ac92 100644 --- a/engine/lib/engine/search/indexer/entry.ex +++ b/engine/lib/engine/search/indexer/entry.ex @@ -40,9 +40,9 @@ defmodule Engine.Search.Indexer.Entry do application: module(), subject: subject(), block_id: block_id(), - block_range: Lexical.Document.Range.t() | nil, + block_range: Engine.Document.Range.t() | nil, path: Path.t(), - range: Lexical.Document.Range.t(), + range: Engine.Document.Range.t(), subtype: entry_subtype(), type: entry_type(), metadata: nil | map() @@ -50,9 +50,9 @@ defmodule Engine.Search.Indexer.Entry do @type datetime_format :: :erl | :unix | :datetime @type date_type :: :calendar.datetime() | integer() | DateTime.t() - alias Lexical.Identifier + alias Engine.Identifier alias Engine.Search.Indexer.Source.Block - alias Lexical.StructAccess + alias Engine.StructAccess use StructAccess diff --git a/engine/lib/engine/search/indexer/extractors/ecto_schema.ex b/engine/lib/engine/search/indexer/extractors/ecto_schema.ex index a6c2f720..2bea1596 100644 --- a/engine/lib/engine/search/indexer/extractors/ecto_schema.ex +++ b/engine/lib/engine/search/indexer/extractors/ecto_schema.ex @@ -1,6 +1,6 @@ defmodule Engine.Search.Indexer.Extractors.EctoSchema do - alias Lexical.Ast - alias Lexical.Document.Position + alias Engine.Ast + alias Engine.Document.Position alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Metadata diff --git a/engine/lib/engine/search/indexer/extractors/ex_unit.ex b/engine/lib/engine/search/indexer/extractors/ex_unit.ex index 1639fabd..0765de36 100644 --- a/engine/lib/engine/search/indexer/extractors/ex_unit.ex +++ b/engine/lib/engine/search/indexer/extractors/ex_unit.ex @@ -1,9 +1,9 @@ defmodule Engine.Search.Indexer.Extractors.ExUnit do - alias Lexical.Ast - alias Lexical.Ast.Analysis - alias Lexical.Document.Position - alias Lexical.Document.Range - alias Lexical.Formats + alias Engine.Ast + alias Engine.Ast.Analysis + alias Engine.Document.Position + alias Engine.Document.Range + alias Engine.Formats alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Metadata diff --git a/engine/lib/engine/search/indexer/extractors/function_definition.ex b/engine/lib/engine/search/indexer/extractors/function_definition.ex index fd746884..a652acb5 100644 --- a/engine/lib/engine/search/indexer/extractors/function_definition.ex +++ b/engine/lib/engine/search/indexer/extractors/function_definition.ex @@ -1,6 +1,6 @@ defmodule Engine.Search.Indexer.Extractors.FunctionDefinition do - alias Lexical.Ast - alias Lexical.Ast.Analysis + alias Engine.Ast + alias Engine.Ast.Analysis alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Source.Reducer diff --git a/engine/lib/engine/search/indexer/extractors/function_reference.ex b/engine/lib/engine/search/indexer/extractors/function_reference.ex index 6d7d264a..b5e426e7 100644 --- a/engine/lib/engine/search/indexer/extractors/function_reference.ex +++ b/engine/lib/engine/search/indexer/extractors/function_reference.ex @@ -1,7 +1,7 @@ defmodule Engine.Search.Indexer.Extractors.FunctionReference do - alias Lexical.Ast - alias Lexical.Document.Position - alias Lexical.Document.Range + alias Engine.Ast + alias Engine.Document.Position + alias Engine.Document.Range alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Extractors.FunctionDefinition @@ -110,7 +110,7 @@ defmodule Engine.Search.Indexer.Extractors.FunctionReference do Entry.reference( analysis.document.path, Reducer.current_block(reducer), - Lexical.Formats.mfa(module, function_name, arity), + Engine.Formats.mfa(module, function_name, arity), {:function, :usage}, Ast.Range.get(ast, analysis.document), Application.get_application(module) diff --git a/engine/lib/engine/search/indexer/extractors/module.ex b/engine/lib/engine/search/indexer/extractors/module.ex index 0f0706d5..aefb01b6 100644 --- a/engine/lib/engine/search/indexer/extractors/module.ex +++ b/engine/lib/engine/search/indexer/extractors/module.ex @@ -3,10 +3,10 @@ defmodule Engine.Search.Indexer.Extractors.Module do Extracts module references and definitions from AST """ - alias Lexical.Ast - alias Lexical.Document.Position - alias Lexical.Document.Range - alias Lexical.ProcessCache + alias Engine.Ast + alias Engine.Document.Position + alias Engine.Document.Range + alias Engine.ProcessCache alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Metadata diff --git a/engine/lib/engine/search/indexer/extractors/module_attribute.ex b/engine/lib/engine/search/indexer/extractors/module_attribute.ex index 053a6531..2dc4da4c 100644 --- a/engine/lib/engine/search/indexer/extractors/module_attribute.ex +++ b/engine/lib/engine/search/indexer/extractors/module_attribute.ex @@ -3,8 +3,8 @@ defmodule Engine.Search.Indexer.Extractors.ModuleAttribute do Extracts module attribute definitions and references from AST """ - alias Lexical.Document.Position - alias Lexical.Document.Range + alias Engine.Document.Position + alias Engine.Document.Range alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Source.Reducer @@ -95,7 +95,7 @@ defmodule Engine.Search.Indexer.Extractors.ModuleAttribute do [line: start_line, column: start_column] = Sourceror.get_start_position(attr_ast) end_line = Sourceror.get_end_line(attr_ast) - {:ok, line_text} = Lexical.Document.fetch_text_at(document, end_line) + {:ok, line_text} = Engine.Document.fetch_text_at(document, end_line) # add one because lsp positions are one-based end_column = String.length(line_text) + 1 diff --git a/engine/lib/engine/search/indexer/extractors/struct_definition.ex b/engine/lib/engine/search/indexer/extractors/struct_definition.ex index 0a63a190..6ed2deb8 100644 --- a/engine/lib/engine/search/indexer/extractors/struct_definition.ex +++ b/engine/lib/engine/search/indexer/extractors/struct_definition.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Indexer.Extractors.StructDefinition do - alias Lexical.Ast + alias Engine.Ast alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Source.Reducer diff --git a/engine/lib/engine/search/indexer/extractors/struct_reference.ex b/engine/lib/engine/search/indexer/extractors/struct_reference.ex index 718e6f7a..22e40d0f 100644 --- a/engine/lib/engine/search/indexer/extractors/struct_reference.ex +++ b/engine/lib/engine/search/indexer/extractors/struct_reference.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Indexer.Extractors.StructReference do - alias Lexical.Ast + alias Engine.Ast alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Source.Reducer diff --git a/engine/lib/engine/search/indexer/extractors/variable.ex b/engine/lib/engine/search/indexer/extractors/variable.ex index 63867c47..d4646d9c 100644 --- a/engine/lib/engine/search/indexer/extractors/variable.ex +++ b/engine/lib/engine/search/indexer/extractors/variable.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Indexer.Extractors.Variable do - alias Lexical.Ast + alias Engine.Ast alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Source.Reducer diff --git a/engine/lib/engine/search/indexer/quoted.ex b/engine/lib/engine/search/indexer/quoted.ex index c0637ea9..10de91b1 100644 --- a/engine/lib/engine/search/indexer/quoted.ex +++ b/engine/lib/engine/search/indexer/quoted.ex @@ -1,6 +1,6 @@ defmodule Engine.Search.Indexer.Quoted do - alias Lexical.Ast.Analysis - alias Lexical.ProcessCache + alias Engine.Ast.Analysis + alias Engine.ProcessCache alias Engine.Search.Indexer.Source.Reducer require ProcessCache diff --git a/engine/lib/engine/search/indexer/source.ex b/engine/lib/engine/search/indexer/source.ex index 5c37e6c3..4ce84086 100644 --- a/engine/lib/engine/search/indexer/source.ex +++ b/engine/lib/engine/search/indexer/source.ex @@ -1,6 +1,6 @@ defmodule Engine.Search.Indexer.Source do - alias Lexical.Ast - alias Lexical.Document + alias Engine.Ast + alias Engine.Document alias Engine.Search.Indexer require Logger diff --git a/engine/lib/engine/search/indexer/source/block.ex b/engine/lib/engine/search/indexer/source/block.ex index e6be318d..766869fa 100644 --- a/engine/lib/engine/search/indexer/source/block.ex +++ b/engine/lib/engine/search/indexer/source/block.ex @@ -4,7 +4,7 @@ defmodule Engine.Search.Indexer.Source.Block do """ defstruct [:starts_at, :ends_at, :id, :parent_id] - alias Lexical.Identifier + alias Engine.Identifier def root do %__MODULE__{id: :root} diff --git a/engine/lib/engine/search/indexer/source/reducer.ex b/engine/lib/engine/search/indexer/source/reducer.ex index 8b5280e0..29c9fba8 100644 --- a/engine/lib/engine/search/indexer/source/reducer.ex +++ b/engine/lib/engine/search/indexer/source/reducer.ex @@ -6,8 +6,8 @@ defmodule Engine.Search.Indexer.Source.Reducer do with the AST's overall structure, and can focus on extracting content from it. """ - alias Lexical.Ast.Analysis - alias Lexical.Document.Position + alias Engine.Ast.Analysis + alias Engine.Document.Position alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Extractors alias Engine.Search.Indexer.Metadata diff --git a/engine/lib/engine/search/store.ex b/engine/lib/engine/search/store.ex index 70632090..8e84fcb5 100644 --- a/engine/lib/engine/search/store.ex +++ b/engine/lib/engine/search/store.ex @@ -3,7 +3,7 @@ defmodule Engine.Search.Store do A persistent store for search entries """ - alias Lexical.Project + alias Engine.Project alias Engine.Api alias Engine.Search.Indexer.Entry diff --git a/engine/lib/engine/search/store/backend.ex b/engine/lib/engine/search/store/backend.ex index 15963e7c..5e9edd1a 100644 --- a/engine/lib/engine/search/store/backend.ex +++ b/engine/lib/engine/search/store/backend.ex @@ -2,7 +2,7 @@ defmodule Engine.Search.Store.Backend do @moduledoc """ A behaviour for search store backends """ - alias Lexical.Project + alias Engine.Project alias Engine.Search.Indexer.Entry @type version :: pos_integer() diff --git a/engine/lib/engine/search/store/backends/ets.ex b/engine/lib/engine/search/store/backends/ets.ex index 0c260b5d..b77a687a 100644 --- a/engine/lib/engine/search/store/backends/ets.ex +++ b/engine/lib/engine/search/store/backends/ets.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Store.Backends.Ets do - alias Lexical.Project + alias Engine.Project alias Engine.Search.Indexer.Entry alias Engine.Search.Store.Backend diff --git a/engine/lib/engine/search/store/backends/ets/schema.ex b/engine/lib/engine/search/store/backends/ets/schema.ex index bffee6bd..89a826ab 100644 --- a/engine/lib/engine/search/store/backends/ets/schema.ex +++ b/engine/lib/engine/search/store/backends/ets/schema.ex @@ -16,7 +16,7 @@ defmodule Engine.Search.Store.Backends.Ets.Schema do quote do @behaviour unquote(__MODULE__) @version unquote(version) - alias Lexical.Project + alias Engine.Project import unquote(__MODULE__), only: [defkey: 2] def version do @@ -43,7 +43,7 @@ defmodule Engine.Search.Store.Backends.Ets.Schema do end end - alias Lexical.Project + alias Engine.Project alias Engine.Search.Indexer.Entry alias Engine.Search.Store.Backends.Ets.Wal diff --git a/engine/lib/engine/search/store/backends/ets/state.ex b/engine/lib/engine/search/store/backends/ets/state.ex index 6551b4ed..cd49cc6b 100644 --- a/engine/lib/engine/search/store/backends/ets/state.ex +++ b/engine/lib/engine/search/store/backends/ets/state.ex @@ -5,7 +5,7 @@ defmodule Engine.Search.Store.Backends.Ets.State do This backend uses an ETS table to store its data using a schema defined in the schemas submodule. """ - alias Lexical.Project + alias Engine.Project alias Engine.Search.Indexer.Entry alias Engine.Search.Store.Backends.Ets.Schema alias Engine.Search.Store.Backends.Ets.Schemas diff --git a/engine/lib/engine/search/store/backends/ets/wal.ex b/engine/lib/engine/search/store/backends/ets/wal.ex index 1786534d..f2157e90 100644 --- a/engine/lib/engine/search/store/backends/ets/wal.ex +++ b/engine/lib/engine/search/store/backends/ets/wal.ex @@ -2,9 +2,9 @@ defmodule Engine.Search.Store.Backends.Ets.Wal do @moduledoc """ A (hopefully) simple write-ahead log """ - alias Lexical.Identifier - alias Lexical.Project - alias Lexical.VM.Versions + alias Engine.Identifier + alias Engine.Project + alias Engine.VM.Versions import Record diff --git a/engine/lib/engine/search/store/state.ex b/engine/lib/engine/search/store/state.ex index 4df8f30d..953c5dc8 100644 --- a/engine/lib/engine/search/store/state.ex +++ b/engine/lib/engine/search/store/state.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Store.State do - alias Lexical.Project + alias Engine.Project alias Engine.Api.Messages alias Engine.Dispatch alias Engine.Search.Fuzzy diff --git a/engine/lib/engine/search/subject.ex b/engine/lib/engine/search/subject.ex index 33f05f4b..5308f3a6 100644 --- a/engine/lib/engine/search/subject.ex +++ b/engine/lib/engine/search/subject.ex @@ -2,7 +2,7 @@ defmodule Engine.Search.Subject do @moduledoc """ Functions for converting to a search entry's subject field """ - alias Lexical.Formats + alias Engine.Formats def module(module) do module diff --git a/engine/lib/engine/struct_access.ex b/engine/lib/engine/struct_access.ex new file mode 100644 index 00000000..bde5f26a --- /dev/null +++ b/engine/lib/engine/struct_access.ex @@ -0,0 +1,43 @@ +defmodule Engine.StructAccess do + @moduledoc """ + Allows structs to easily adopt the `Access` behaviour. + """ + defmacro __using__(_) do + quote location: :keep do + @doc false + def fetch(struct, key) when is_map_key(struct, key) do + {:ok, Map.get(struct, key)} + end + + @doc false + def fetch(_, _) do + :error + end + + @doc false + def get_and_update(struct, key, function) when is_map_key(struct, key) do + old_value = Map.get(struct, key) + + case function.(old_value) do + {current_value, updated_value} -> {current_value, Map.put(struct, key, updated_value)} + :pop -> {old_value, Map.put(struct, key, nil)} + end + end + + @doc false + def get_and_update(struct, key, function) do + {{:error, {:nonexistent_key, key}}, struct} + end + + @doc false + def pop(struct, key) when is_map_key(struct, key) do + {Map.get(struct, key), struct} + end + + @doc false + def pop(struct, _key) do + {nil, struct} + end + end + end +end diff --git a/engine/lib/engine/text.ex b/engine/lib/engine/text.ex new file mode 100644 index 00000000..395c9bbd --- /dev/null +++ b/engine/lib/engine/text.ex @@ -0,0 +1,8 @@ +defmodule Engine.Text do + def count_leading_spaces(str), do: count_leading_spaces(str, 0) + + def count_leading_spaces(<>, count) when c in [?\s, ?\t], + do: count_leading_spaces(rest, count + 1) + + def count_leading_spaces(_, count), do: count +end diff --git a/engine/mix.exs b/engine/mix.exs index bf0a3e9c..55113d79 100644 --- a/engine/mix.exs +++ b/engine/mix.exs @@ -23,6 +23,7 @@ defmodule Engine.MixProject do defp deps do [ {:spitfire, "~> 0.1"}, + {:sourceror, "~> 1.0"}, # {:gen_lsp, "~> 0.10"}, {:gen_lsp, github: "elixir-tools/gen_lsp", branch: "change-schematic-function", override: true}, diff --git a/engine/mix.lock b/engine/mix.lock index 91ee44f8..08c4163e 100644 --- a/engine/mix.lock +++ b/engine/mix.lock @@ -4,6 +4,7 @@ "jason": {:hex, :jason, "1.4.4", "b9226785a9aa77b6857ca22832cffa5d5011a667207eb2a0ad56adb5db443b8a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "c5eb0cab91f094599f94d55bc63409236a8ec69a21a67814529e8d5f6cc90b3b"}, "nimble_options": {:hex, :nimble_options, "1.1.1", "e3a492d54d85fc3fd7c5baf411d9d2852922f66e69476317787a7b2bb000a61b", [:mix], [], "hexpm", "821b2470ca9442c4b6984882fe9bb0389371b8ddec4d45a9504f00a66f650b44"}, "schematic": {:hex, :schematic, "0.2.1", "0b091df94146fd15a0a343d1bd179a6c5a58562527746dadd09477311698dbb1", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "0b255d65921e38006138201cd4263fd8bb807d9dfc511074615cd264a571b3b1"}, + "sourceror": {:hex, :sourceror, "1.7.1", "599d78f4cc2be7d55c9c4fd0a8d772fd0478e3a50e726697c20d13d02aa056d4", [:mix], [], "hexpm", "cd6f268fe29fa00afbc535e215158680a0662b357dc784646d7dff28ac65a0fc"}, "spitfire": {:hex, :spitfire, "0.1.3", "7ea0f544005dfbe48e615ed90250c9a271bfe126914012023fd5e4b6b82b7ec7", [:mix], [], "hexpm", "d53b5107bcff526a05c5bb54c95e77b36834550affd5830c9f58760e8c543657"}, "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"}, "typed_struct": {:hex, :typed_struct, "0.3.0", "939789e3c1dca39d7170c87f729127469d1315dcf99fee8e152bb774b17e7ff7", [:mix], [], "hexpm", "c50bd5c3a61fe4e198a8504f939be3d3c85903b382bde4865579bc23111d1b6d"}, From 7f02e90e71137fbbc109786bd696e223ee22c13d Mon Sep 17 00:00:00 2001 From: Mitchell Hanberg Date: Wed, 1 Jan 2025 14:42:43 -0500 Subject: [PATCH 06/12] wip: bring over apps/common and call it forge --- engine/lib/engine/analyzer.ex | 12 +- engine/lib/engine/analyzer/aliases.ex | 8 +- engine/lib/engine/analyzer/imports.ex | 10 +- engine/lib/engine/analyzer/requires.ex | 8 +- engine/lib/engine/analyzer/uses.ex | 6 +- engine/lib/engine/api.ex | 12 +- engine/lib/engine/api/messages.ex | 30 +- engine/lib/engine/api/proxy.ex | 4 +- .../lib/engine/api/proxy/buffering_state.ex | 2 +- engine/lib/engine/application.ex | 2 - engine/lib/engine/bootstrap.ex | 4 +- engine/lib/engine/build.ex | 4 +- engine/lib/engine/build/document.ex | 2 +- engine/lib/engine/build/document/compiler.ex | 2 +- .../engine/build/document/compilers/config.ex | 2 +- .../engine/build/document/compilers/eex.ex | 4 +- .../engine/build/document/compilers/elixir.ex | 2 +- .../engine/build/document/compilers/heex.ex | 4 +- .../engine/build/document/compilers/quoted.ex | 4 +- engine/lib/engine/build/error.ex | 6 +- engine/lib/engine/build/error/location.ex | 8 +- engine/lib/engine/build/error/parse.ex | 6 +- engine/lib/engine/build/project.ex | 7 +- engine/lib/engine/build/state.ex | 7 +- engine/lib/engine/code_action.ex | 10 +- engine/lib/engine/code_action/diagnostic.ex | 2 +- engine/lib/engine/code_action/handler.ex | 4 +- .../engine/code_action/handlers/add_alias.ex | 15 +- .../code_action/handlers/organize_aliases.ex | 10 +- .../handlers/remove_unused_alias.ex | 14 +- .../handlers/replace_remote_function.ex | 10 +- .../handlers/replace_with_underscore.ex | 8 +- .../engine/code_intelligence/definition.ex | 10 +- engine/lib/engine/code_intelligence/entity.ex | 10 +- .../engine/code_intelligence/references.ex | 8 +- .../lib/engine/code_intelligence/symbols.ex | 4 +- .../code_intelligence/symbols/document.ex | 2 +- .../code_intelligence/symbols/workspace.ex | 8 +- .../lib/engine/code_intelligence/variable.ex | 6 +- engine/lib/engine/code_mod/aliases.ex | 16 +- engine/lib/engine/code_mod/diff.ex | 8 +- engine/lib/engine/code_mod/format.ex | 6 +- engine/lib/engine/commands/reindex.ex | 8 +- engine/lib/engine/completion.ex | 10 +- engine/lib/engine/convertible.ex | 10 +- .../lib/engine/dispatch/handlers/indexing.ex | 2 +- engine/lib/engine/dispatch/pub_sub.ex | 4 +- engine/lib/engine/engine.ex | 8 +- engine/lib/engine/mix.ex | 2 +- engine/lib/engine/plugin.ex | 48 - engine/lib/engine/plugin/discovery.ex | 73 - engine/lib/engine/plugin/runner.ex | 118 - .../lib/engine/plugin/runner/coordinator.ex | 35 - .../engine/plugin/runner/coordinator/state.ex | 102 - engine/lib/engine/plugin/supervisor.ex | 20 - engine/lib/engine/port.ex | 2 +- engine/lib/engine/project_node.ex | 4 +- engine/lib/engine/project_node_supervisor.ex | 2 +- engine/lib/engine/search/fuzzy.ex | 2 +- engine/lib/engine/search/indexer.ex | 2 +- engine/lib/engine/search/indexer/entry.ex | 6 +- .../search/indexer/extractors/ecto_schema.ex | 4 +- .../search/indexer/extractors/ex_unit.ex | 8 +- .../indexer/extractors/function_definition.ex | 4 +- .../indexer/extractors/function_reference.ex | 6 +- .../search/indexer/extractors/module.ex | 6 +- .../indexer/extractors/module_attribute.ex | 6 +- .../indexer/extractors/struct_definition.ex | 2 +- .../indexer/extractors/struct_reference.ex | 2 +- .../search/indexer/extractors/variable.ex | 2 +- engine/lib/engine/search/indexer/quoted.ex | 2 +- engine/lib/engine/search/indexer/source.ex | 4 +- .../engine/search/indexer/source/reducer.ex | 4 +- engine/lib/engine/search/store.ex | 2 +- engine/lib/engine/search/store/backend.ex | 2 +- .../lib/engine/search/store/backends/ets.ex | 2 +- .../search/store/backends/ets/schema.ex | 4 +- .../engine/search/store/backends/ets/state.ex | 2 +- .../engine/search/store/backends/ets/wal.ex | 2 +- engine/lib/engine/search/store/state.ex | 2 +- engine/mix.exs | 1 + forge/.formatter.exs | 26 + forge/.gitignore | 26 + forge/README.md | 21 + forge/lib/elixir/features.ex | 42 + forge/lib/forge.ex | 7 + forge/lib/forge/ast.ex | 731 + forge/lib/forge/ast/analysis.ex | 539 + forge/lib/forge/ast/analysis/alias.ex | 52 + forge/lib/forge/ast/analysis/import.ex | 92 + forge/lib/forge/ast/analysis/require.ex | 10 + forge/lib/forge/ast/analysis/scope.ex | 86 + forge/lib/forge/ast/analysis/state.ex | 180 + forge/lib/forge/ast/analysis/use.ex | 10 + forge/lib/forge/ast/detection.ex | 109 + forge/lib/forge/ast/detection/alias.ex | 64 + forge/lib/forge/ast/detection/bitstring.ex | 26 + forge/lib/forge/ast/detection/comment.ex | 8 + forge/lib/forge/ast/detection/directive.ex | 21 + .../forge/ast/detection/function_capture.ex | 32 + forge/lib/forge/ast/detection/import.ex | 13 + .../forge/ast/detection/module_attribute.ex | 16 + forge/lib/forge/ast/detection/pipe.ex | 34 + forge/lib/forge/ast/detection/require.ex | 13 + forge/lib/forge/ast/detection/spec.ex | 12 + forge/lib/forge/ast/detection/string.ex | 109 + .../forge/ast/detection/struct_field_key.ex | 21 + .../forge/ast/detection/struct_field_value.ex | 11 + .../lib/forge/ast/detection/struct_fields.ex | 15 + .../forge/ast/detection/struct_reference.ex | 43 + forge/lib/forge/ast/detection/type.ex | 12 + forge/lib/forge/ast/detection/use.ex | 13 + forge/lib/forge/ast/env.ex | 238 + forge/lib/forge/ast/module.ex | 99 + forge/lib/forge/ast/range.ex | 48 + forge/lib/forge/ast/tokens.ex | 169 + forge/lib/forge/code_unit.ex | 125 + .../engine => forge/lib/forge}/document.ex | 28 +- .../lib/forge}/document/changes.ex | 8 +- .../lib/forge}/document/container.ex | 10 +- .../lib/forge}/document/edit.ex | 8 +- .../lib/forge}/document/line.ex | 2 +- .../lib/forge}/document/line_parser.ex | 6 +- .../lib/forge}/document/lines.ex | 18 +- .../lib/forge}/document/location.ex | 14 +- .../lib/forge}/document/path.ex | 8 +- .../lib/forge}/document/position.ex | 14 +- .../lib/forge}/document/range.ex | 8 +- .../lib/forge}/document/store.ex | 52 +- forge/lib/forge/identifier.ex | 27 + .../lib/forge/plugin/v1/diagnostic/result.ex | 105 + .../lib/engine => forge/lib/forge}/project.ex | 8 +- .../lib/forge}/struct_access.ex | 2 +- forge/lib/forge/vm/versions.ex | 228 + forge/lib/future/code.ex | 2095 + forge/lib/future/code/fragment.ex | 1132 + forge/lib/future/code/indentifier.ex | 153 + forge/lib/future/code/typespec.ex | 433 + forge/lib/future/macro.ex | 95 + forge/lib/mix/tasks/hooks.ex | 39 + forge/mix.exs | 30 + forge/src/future_elixir.erl | 542 + forge/src/future_elixir.hrl | 43 + forge/src/future_elixir_errors.erl | 526 + forge/src/future_elixir_interpolation.erl | 295 + forge/src/future_elixir_parser.erl | 33586 ++++++++++++++++ forge/src/future_elixir_parser.yrl | 1284 + forge/src/future_elixir_tokenizer.erl | 1827 + forge/src/future_elixir_tokenizer.hrl | 34 + .../test/lexical/ast/detection/alias_test.exs | 7 + .../lexical/ast/detection/bitstring_test.exs | 6 + .../lexical/ast/detection/comment_test.exs | 7 + .../ast/detection/function_capture_test.exs | 32 + .../lexical/ast/detection/import_test.exs | 16 + .../ast/detection/module_attribute_test.exs | 17 + .../test/lexical/ast/detection/pipe_test.exs | 13 + .../lexical/ast/detection/require_test.exs | 7 + .../test/lexical/ast/detection/spec_test.exs | 7 + .../lexical/ast/detection/string_test.exs | 25 + .../ast/detection/struct_field_key_test.exs | 17 + .../ast/detection/struct_field_value_test.exs | 25 + .../ast/detection/struct_fields_test.exs | 33 + .../ast/detection/struct_reference_test.exs | 45 + .../test/lexical/ast/detection/type_test.exs | 18 + forge/test/lexical/ast/detection/use_test.exs | 7 + forge/test/lexical/ast/env_test.exs | 236 + forge/test/lexical/ast/module_test.exs | 26 + forge/test/lexical/ast/tokens_test.exs | 51 + forge/test/lexical/ast_test.exs | 347 + forge/test/lexical/code_unit_test.exs | 77 + forge/test/lexical/math_test.exs | 40 + forge/test/lexical/vm/versions_test.exs | 115 + .../support/lexical/test/detection_case.ex | 337 + .../lexical/test/detection_case/suite.ex | 309 + forge/test/support/lexical/test/variations.ex | 50 + forge/test/test_helper.exs | 2 + 176 files changed, 47722 insertions(+), 715 deletions(-) delete mode 100644 engine/lib/engine/plugin.ex delete mode 100644 engine/lib/engine/plugin/discovery.ex delete mode 100644 engine/lib/engine/plugin/runner.ex delete mode 100644 engine/lib/engine/plugin/runner/coordinator.ex delete mode 100644 engine/lib/engine/plugin/runner/coordinator/state.ex delete mode 100644 engine/lib/engine/plugin/supervisor.ex create mode 100644 forge/.formatter.exs create mode 100644 forge/.gitignore create mode 100644 forge/README.md create mode 100644 forge/lib/elixir/features.ex create mode 100644 forge/lib/forge.ex create mode 100644 forge/lib/forge/ast.ex create mode 100644 forge/lib/forge/ast/analysis.ex create mode 100644 forge/lib/forge/ast/analysis/alias.ex create mode 100644 forge/lib/forge/ast/analysis/import.ex create mode 100644 forge/lib/forge/ast/analysis/require.ex create mode 100644 forge/lib/forge/ast/analysis/scope.ex create mode 100644 forge/lib/forge/ast/analysis/state.ex create mode 100644 forge/lib/forge/ast/analysis/use.ex create mode 100644 forge/lib/forge/ast/detection.ex create mode 100644 forge/lib/forge/ast/detection/alias.ex create mode 100644 forge/lib/forge/ast/detection/bitstring.ex create mode 100644 forge/lib/forge/ast/detection/comment.ex create mode 100644 forge/lib/forge/ast/detection/directive.ex create mode 100644 forge/lib/forge/ast/detection/function_capture.ex create mode 100644 forge/lib/forge/ast/detection/import.ex create mode 100644 forge/lib/forge/ast/detection/module_attribute.ex create mode 100644 forge/lib/forge/ast/detection/pipe.ex create mode 100644 forge/lib/forge/ast/detection/require.ex create mode 100644 forge/lib/forge/ast/detection/spec.ex create mode 100644 forge/lib/forge/ast/detection/string.ex create mode 100644 forge/lib/forge/ast/detection/struct_field_key.ex create mode 100644 forge/lib/forge/ast/detection/struct_field_value.ex create mode 100644 forge/lib/forge/ast/detection/struct_fields.ex create mode 100644 forge/lib/forge/ast/detection/struct_reference.ex create mode 100644 forge/lib/forge/ast/detection/type.ex create mode 100644 forge/lib/forge/ast/detection/use.ex create mode 100644 forge/lib/forge/ast/env.ex create mode 100644 forge/lib/forge/ast/module.ex create mode 100644 forge/lib/forge/ast/range.ex create mode 100644 forge/lib/forge/ast/tokens.ex create mode 100644 forge/lib/forge/code_unit.ex rename {engine/lib/engine => forge/lib/forge}/document.ex (94%) rename {engine/lib/engine => forge/lib/forge}/document/changes.ex (86%) rename {engine/lib/engine => forge/lib/forge}/document/container.ex (89%) rename {engine/lib/engine => forge/lib/forge}/document/edit.ex (80%) rename {engine/lib/engine => forge/lib/forge}/document/line.ex (95%) rename {engine/lib/engine => forge/lib/forge}/document/line_parser.ex (96%) rename {engine/lib/engine => forge/lib/forge}/document/lines.ex (92%) rename {engine/lib/engine => forge/lib/forge}/document/location.ex (80%) rename {engine/lib/engine => forge/lib/forge}/document/path.ex (95%) rename {engine/lib/engine => forge/lib/forge}/document/position.ex (89%) rename {engine/lib/engine => forge/lib/forge}/document/range.ex (91%) rename {engine/lib/engine => forge/lib/forge}/document/store.ex (87%) create mode 100644 forge/lib/forge/identifier.ex create mode 100644 forge/lib/forge/plugin/v1/diagnostic/result.ex rename {engine/lib/engine => forge/lib/forge}/project.ex (98%) rename {engine/lib/engine => forge/lib/forge}/struct_access.ex (96%) create mode 100644 forge/lib/forge/vm/versions.ex create mode 100644 forge/lib/future/code.ex create mode 100644 forge/lib/future/code/fragment.ex create mode 100644 forge/lib/future/code/indentifier.ex create mode 100644 forge/lib/future/code/typespec.ex create mode 100644 forge/lib/future/macro.ex create mode 100644 forge/lib/mix/tasks/hooks.ex create mode 100644 forge/mix.exs create mode 100644 forge/src/future_elixir.erl create mode 100644 forge/src/future_elixir.hrl create mode 100644 forge/src/future_elixir_errors.erl create mode 100644 forge/src/future_elixir_interpolation.erl create mode 100644 forge/src/future_elixir_parser.erl create mode 100644 forge/src/future_elixir_parser.yrl create mode 100644 forge/src/future_elixir_tokenizer.erl create mode 100644 forge/src/future_elixir_tokenizer.hrl create mode 100644 forge/test/lexical/ast/detection/alias_test.exs create mode 100644 forge/test/lexical/ast/detection/bitstring_test.exs create mode 100644 forge/test/lexical/ast/detection/comment_test.exs create mode 100644 forge/test/lexical/ast/detection/function_capture_test.exs create mode 100644 forge/test/lexical/ast/detection/import_test.exs create mode 100644 forge/test/lexical/ast/detection/module_attribute_test.exs create mode 100644 forge/test/lexical/ast/detection/pipe_test.exs create mode 100644 forge/test/lexical/ast/detection/require_test.exs create mode 100644 forge/test/lexical/ast/detection/spec_test.exs create mode 100644 forge/test/lexical/ast/detection/string_test.exs create mode 100644 forge/test/lexical/ast/detection/struct_field_key_test.exs create mode 100644 forge/test/lexical/ast/detection/struct_field_value_test.exs create mode 100644 forge/test/lexical/ast/detection/struct_fields_test.exs create mode 100644 forge/test/lexical/ast/detection/struct_reference_test.exs create mode 100644 forge/test/lexical/ast/detection/type_test.exs create mode 100644 forge/test/lexical/ast/detection/use_test.exs create mode 100644 forge/test/lexical/ast/env_test.exs create mode 100644 forge/test/lexical/ast/module_test.exs create mode 100644 forge/test/lexical/ast/tokens_test.exs create mode 100644 forge/test/lexical/ast_test.exs create mode 100644 forge/test/lexical/code_unit_test.exs create mode 100644 forge/test/lexical/math_test.exs create mode 100644 forge/test/lexical/vm/versions_test.exs create mode 100644 forge/test/support/lexical/test/detection_case.ex create mode 100644 forge/test/support/lexical/test/detection_case/suite.ex create mode 100644 forge/test/support/lexical/test/variations.ex create mode 100644 forge/test/test_helper.exs diff --git a/engine/lib/engine/analyzer.ex b/engine/lib/engine/analyzer.ex index 83706d21..785ce7a1 100644 --- a/engine/lib/engine/analyzer.ex +++ b/engine/lib/engine/analyzer.ex @@ -1,9 +1,9 @@ defmodule Engine.Analyzer do - alias Engine.Ast - alias Engine.Ast.Analysis - alias Engine.Ast.Analysis.Require - alias Engine.Ast.Analysis.Use - alias Engine.Document.Position + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Require + alias Forge.Ast.Analysis.Use + alias Forge.Document.Position alias Engine.Analyzer.Aliases alias Engine.Analyzer.Imports alias Engine.Analyzer.Requires @@ -114,7 +114,7 @@ defmodule Engine.Analyzer do ) :: {:ok, module()} | :error def expand_alias([_ | _] = segments, %Analysis{} = analysis, %Position{} = position) do - with %Analysis{valid?: true} = analysis <- Engine.Ast.reanalyze_to(analysis, position), + with %Analysis{valid?: true} = analysis <- Forge.Ast.reanalyze_to(analysis, position), aliases <- aliases_at(analysis, position), {:ok, resolved} <- resolve_alias(segments, aliases) do {:ok, Module.concat(resolved)} diff --git a/engine/lib/engine/analyzer/aliases.ex b/engine/lib/engine/analyzer/aliases.ex index fea28abf..42636336 100644 --- a/engine/lib/engine/analyzer/aliases.ex +++ b/engine/lib/engine/analyzer/aliases.ex @@ -1,8 +1,8 @@ defmodule Engine.Analyzer.Aliases do - alias Engine.Ast.Analysis - alias Engine.Ast.Analysis.Alias - alias Engine.Ast.Analysis.Scope - alias Engine.Document.Position + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Alias + alias Forge.Ast.Analysis.Scope + alias Forge.Document.Position @spec at(Analysis.t(), Position.t()) :: %{atom() => module()} def at(%Analysis{} = analysis, %Position{} = position) do diff --git a/engine/lib/engine/analyzer/imports.ex b/engine/lib/engine/analyzer/imports.ex index 77eb15c3..a6bdd339 100644 --- a/engine/lib/engine/analyzer/imports.ex +++ b/engine/lib/engine/analyzer/imports.ex @@ -1,9 +1,9 @@ defmodule Engine.Analyzer.Imports do - alias Engine.Ast.Analysis - alias Engine.Ast.Analysis.Import - alias Engine.Ast.Analysis.Scope - alias Engine.Document.Position - alias Engine.Document.Range + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Import + alias Forge.Ast.Analysis.Scope + alias Forge.Document.Position + alias Forge.Document.Range alias Engine.ProcessCache alias Engine.Analyzer.Aliases alias Engine.Module.Loader diff --git a/engine/lib/engine/analyzer/requires.ex b/engine/lib/engine/analyzer/requires.ex index 7ed2c6cf..2f6fe9fb 100644 --- a/engine/lib/engine/analyzer/requires.ex +++ b/engine/lib/engine/analyzer/requires.ex @@ -1,8 +1,8 @@ defmodule Engine.Analyzer.Requires do - alias Engine.Ast.Analysis - alias Engine.Ast.Analysis.Require - alias Engine.Ast.Analysis.Scope - alias Engine.Document.Position + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Require + alias Forge.Ast.Analysis.Scope + alias Forge.Document.Position def at(%Analysis{} = analysis, %Position{} = position) do case Analysis.scopes_at(analysis, position) do diff --git a/engine/lib/engine/analyzer/uses.ex b/engine/lib/engine/analyzer/uses.ex index 3001f3ee..b21db05a 100644 --- a/engine/lib/engine/analyzer/uses.ex +++ b/engine/lib/engine/analyzer/uses.ex @@ -1,7 +1,7 @@ defmodule Engine.Analyzer.Uses do - alias Engine.Ast.Analysis - alias Engine.Ast.Analysis.Scope - alias Engine.Document.Position + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Scope + alias Forge.Document.Position def at(%Analysis{} = analysis, %Position{} = position) do case Analysis.scopes_at(analysis, position) do diff --git a/engine/lib/engine/api.ex b/engine/lib/engine/api.ex index fcd24a92..769cc3c5 100644 --- a/engine/lib/engine/api.ex +++ b/engine/lib/engine/api.ex @@ -1,10 +1,10 @@ defmodule Engine.Api do - alias Engine.Ast.Analysis - alias Engine.Ast.Env - alias Engine.Document - alias Engine.Document.Position - alias Engine.Document.Range - alias Engine.Project + alias Forge.Ast.Analysis + alias Forge.Ast.Env + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Project alias Engine.CodeIntelligence diff --git a/engine/lib/engine/api/messages.ex b/engine/lib/engine/api/messages.ex index f44e2276..49afdada 100644 --- a/engine/lib/engine/api/messages.ex +++ b/engine/lib/engine/api/messages.ex @@ -1,5 +1,5 @@ defmodule Engine.Api.Messages do - alias Engine.Project + alias Forge.Project import Record defrecord :project_compile_requested, project: nil, build_number: 0 @@ -53,12 +53,12 @@ defmodule Engine.Api.Messages do @type project_compile_requested :: record(:project_compile_requested, - project: Engine.Project.t(), + project: Forge.Project.t(), build_number: non_neg_integer() ) @type project_compiled :: record(:project_compiled, - project: Engine.Project.t(), + project: Forge.Project.t(), build_number: non_neg_integer(), status: compile_status, elapsed_ms: non_neg_integer @@ -67,13 +67,13 @@ defmodule Engine.Api.Messages do @type filesystem_event :: record(:filesystem_event, project: Project.t(), - uri: Engine.uri(), + uri: Forge.uri(), event_type: :created | :updated | :deleted ) @type file_changed :: record(:file_changed, - uri: Engine.uri(), + uri: Forge.uri(), from_version: maybe_version, to_version: maybe_version, open?: boolean() @@ -81,16 +81,16 @@ defmodule Engine.Api.Messages do @type file_compile_requested :: record(:file_compile_requested, - project: Engine.Project.t(), + project: Forge.Project.t(), build_number: non_neg_integer(), - uri: Engine.uri() + uri: Forge.uri() ) @type file_compiled :: record(:file_compiled, - project: Engine.Project.t(), + project: Forge.Project.t(), build_number: non_neg_integer(), - uri: Engine.uri(), + uri: Forge.uri(), status: compile_status, elapsed_ms: non_neg_integer ) @@ -105,14 +105,14 @@ defmodule Engine.Api.Messages do @type project_diagnostics :: record(:project_diagnostics, - project: Engine.Project.t(), + project: Forge.Project.t(), diagnostics: diagnostics() ) @type file_diagnostics :: record(:file_diagnostics, - project: Engine.Project.t(), - uri: Engine.uri(), + project: Forge.Project.t(), + uri: Forge.uri(), diagnostics: diagnostics() ) @@ -125,14 +125,14 @@ defmodule Engine.Api.Messages do @type struct_discovered :: record(:struct_discovered, module: module(), fields: field_list()) - @type project_index_ready :: record(:project_index_ready, project: Engine.Project.t()) + @type project_index_ready :: record(:project_index_ready, project: Forge.Project.t()) @type project_reindex_requested :: - record(:project_reindex_requested, project: Engine.Project.t()) + record(:project_reindex_requested, project: Forge.Project.t()) @type project_reindexed :: record(:project_reindexed, - project: Engine.Project.t(), + project: Forge.Project.t(), elapsed_ms: non_neg_integer(), status: :success | {:error, term()} ) diff --git a/engine/lib/engine/api/proxy.ex b/engine/lib/engine/api/proxy.ex index d0b55c95..9b669d24 100644 --- a/engine/lib/engine/api/proxy.ex +++ b/engine/lib/engine/api/proxy.ex @@ -30,8 +30,8 @@ defmodule Engine.Api.Proxy do """ - alias Engine.Document - alias Engine.Document.Changes + alias Forge.Document + alias Forge.Document.Changes alias Engine.Api.Messages alias Engine.Api.Proxy.BufferingState diff --git a/engine/lib/engine/api/proxy/buffering_state.ex b/engine/lib/engine/api/proxy/buffering_state.ex index 362a591a..6cd23c40 100644 --- a/engine/lib/engine/api/proxy/buffering_state.ex +++ b/engine/lib/engine/api/proxy/buffering_state.ex @@ -1,5 +1,5 @@ defmodule Engine.Api.Proxy.BufferingState do - alias Engine.Document + alias Forge.Document alias Engine.Api alias Engine.Build diff --git a/engine/lib/engine/application.ex b/engine/lib/engine/application.ex index 395909f0..55ee379e 100644 --- a/engine/lib/engine/application.ex +++ b/engine/lib/engine/application.ex @@ -16,8 +16,6 @@ defmodule Engine.Application do Engine.ModuleMappings, Engine.Build, Engine.Build.CaptureServer, - Engine.Plugin.Runner.Supervisor, - Engine.Plugin.Runner.Coordinator, Engine.Search.Store.Backends.Ets, {Engine.Search.Store, [ diff --git a/engine/lib/engine/bootstrap.ex b/engine/lib/engine/bootstrap.ex index 366e11f8..bd005ca6 100644 --- a/engine/lib/engine/bootstrap.ex +++ b/engine/lib/engine/bootstrap.ex @@ -6,12 +6,12 @@ defmodule Engine.Bootstrap do the project's code paths, which are then added to the code paths from the language server. At this point, it's safe to start the project, as we should have all the code present to compile the system. """ - alias Engine.Project + alias Forge.Project require Logger def init(%Project{} = project, document_store_entropy, app_configs) do - Engine.Document.Store.set_entropy(document_store_entropy) + Forge.Document.Store.set_entropy(document_store_entropy) Application.put_all_env(app_configs) diff --git a/engine/lib/engine/build.ex b/engine/lib/engine/build.ex index feda6877..d4d36b92 100644 --- a/engine/lib/engine/build.ex +++ b/engine/lib/engine/build.ex @@ -1,6 +1,6 @@ defmodule Engine.Build do - alias Engine.Document - alias Engine.Project + alias Forge.Document + alias Forge.Project alias Engine.Build.Document.Compilers.HEEx alias Engine.Build.State diff --git a/engine/lib/engine/build/document.ex b/engine/lib/engine/build/document.ex index 9f9a044b..ae9976d7 100644 --- a/engine/lib/engine/build/document.ex +++ b/engine/lib/engine/build/document.ex @@ -1,5 +1,5 @@ defmodule Engine.Build.Document do - alias Engine.Document + alias Forge.Document alias Engine.Build alias Engine.Build.Document.Compilers alias Engine.Build.Isolation diff --git a/engine/lib/engine/build/document/compiler.ex b/engine/lib/engine/build/document/compiler.ex index 9b19eec8..71e7e52d 100644 --- a/engine/lib/engine/build/document/compiler.ex +++ b/engine/lib/engine/build/document/compiler.ex @@ -2,7 +2,7 @@ defmodule Engine.Build.Document.Compiler do @moduledoc """ A behaviour for document-level compilers """ - alias Engine.Document + alias Forge.Document alias Engine.Plugin.V1.Diagnostic @type compile_response :: {:ok, [Diagnostic.Result.t()]} | {:error, [Diagnostic.Result.t()]} diff --git a/engine/lib/engine/build/document/compilers/config.ex b/engine/lib/engine/build/document/compilers/config.ex index 360cb8af..ec8df84b 100644 --- a/engine/lib/engine/build/document/compilers/config.ex +++ b/engine/lib/engine/build/document/compilers/config.ex @@ -3,7 +3,7 @@ defmodule Engine.Build.Document.Compilers.Config do A compiler for elixir configuration """ alias Elixir.Features - alias Engine.Document + alias Forge.Document alias Engine.Plugin.V1.Diagnostic alias Engine.Build alias Engine.Build.Error.Location diff --git a/engine/lib/engine/build/document/compilers/eex.ex b/engine/lib/engine/build/document/compilers/eex.ex index c6dba628..c3508344 100644 --- a/engine/lib/engine/build/document/compilers/eex.ex +++ b/engine/lib/engine/build/document/compilers/eex.ex @@ -2,8 +2,8 @@ defmodule Engine.Build.Document.Compilers.EEx do @moduledoc """ A compiler for .eex files """ - alias Engine.Document - alias Engine.Plugin.V1.Diagnostic.Result + alias Forge.Document + alias Forge.Plugin.V1.Diagnostic.Result alias Engine.Build alias Engine.Build.Document.Compiler alias Engine.Build.Document.Compilers diff --git a/engine/lib/engine/build/document/compilers/elixir.ex b/engine/lib/engine/build/document/compilers/elixir.ex index b6c8f96e..2e7cbcbd 100644 --- a/engine/lib/engine/build/document/compilers/elixir.ex +++ b/engine/lib/engine/build/document/compilers/elixir.ex @@ -4,7 +4,7 @@ defmodule Engine.Build.Document.Compilers.Elixir do """ alias Elixir.Features - alias Engine.Document + alias Forge.Document alias Engine.Build alias Engine.Build.Document.Compilers diff --git a/engine/lib/engine/build/document/compilers/heex.ex b/engine/lib/engine/build/document/compilers/heex.ex index 2e093eca..8826417b 100644 --- a/engine/lib/engine/build/document/compilers/heex.ex +++ b/engine/lib/engine/build/document/compilers/heex.ex @@ -2,8 +2,8 @@ defmodule Engine.Build.Document.Compilers.HEEx do @moduledoc """ A compiler for .heex files """ - alias Engine.Document - alias Engine.Plugin.V1.Diagnostic.Result + alias Forge.Document + alias Forge.Plugin.V1.Diagnostic.Result alias Engine.Build.Document.Compiler alias Engine.Build.Document.Compilers require Logger diff --git a/engine/lib/engine/build/document/compilers/quoted.ex b/engine/lib/engine/build/document/compilers/quoted.ex index 47570408..4499523a 100644 --- a/engine/lib/engine/build/document/compilers/quoted.ex +++ b/engine/lib/engine/build/document/compilers/quoted.ex @@ -1,7 +1,7 @@ defmodule Engine.Build.Document.Compilers.Quoted do alias Elixir.Features - alias Engine.Ast - alias Engine.Document + alias Forge.Ast + alias Forge.Document alias Engine.Build alias Engine.ModuleMappings diff --git a/engine/lib/engine/build/error.ex b/engine/lib/engine/build/error.ex index 73866541..0d4dfd62 100644 --- a/engine/lib/engine/build/error.ex +++ b/engine/lib/engine/build/error.ex @@ -1,7 +1,7 @@ defmodule Engine.Build.Error do - alias Engine.Ast - alias Engine.Document - alias Engine.Plugin.V1.Diagnostic.Result + alias Forge.Ast + alias Forge.Document + alias Forge.Plugin.V1.Diagnostic.Result alias Engine.Build.Error.Location alias Mix.Task.Compiler diff --git a/engine/lib/engine/build/error/location.ex b/engine/lib/engine/build/error/location.ex index 8dc8a903..4809e837 100644 --- a/engine/lib/engine/build/error/location.ex +++ b/engine/lib/engine/build/error/location.ex @@ -1,8 +1,8 @@ defmodule Engine.Build.Error.Location do - alias Engine.Document - alias Engine.Document.Position - alias Engine.Document.Range - alias Engine.Plugin.V1.Diagnostic.Result + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Plugin.V1.Diagnostic.Result require Logger diff --git a/engine/lib/engine/build/error/parse.ex b/engine/lib/engine/build/error/parse.ex index debeec3e..f86adbc3 100644 --- a/engine/lib/engine/build/error/parse.ex +++ b/engine/lib/engine/build/error/parse.ex @@ -1,7 +1,7 @@ defmodule Engine.Build.Error.Parse do - alias Engine.Document - alias Engine.Document.Range - alias Engine.Plugin.V1.Diagnostic.Result + alias Forge.Document + alias Forge.Document.Range + alias Forge.Plugin.V1.Diagnostic.Result alias Engine.Build.Error.Location @elixir_source "Elixir" diff --git a/engine/lib/engine/build/project.ex b/engine/lib/engine/build/project.ex index 9dc9da3d..81b96ea8 100644 --- a/engine/lib/engine/build/project.ex +++ b/engine/lib/engine/build/project.ex @@ -1,9 +1,8 @@ defmodule Engine.Build.Project do - alias Engine.Project + alias Forge.Project alias Engine.Build alias Engine.Build.Isolation - alias Engine.Plugin alias Mix.Task.Compiler.Diagnostic use Engine.Progress @@ -94,10 +93,6 @@ defmodule Engine.Build.Project do with_progress("mix deps.compile", fn -> Mix.Task.run("deps.safe_compile", ~w(--skip-umbrella-children)) end) - - with_progress("loading plugins", fn -> - Plugin.Discovery.run() - end) end defp connected_to_internet? do diff --git a/engine/lib/engine/build/state.ex b/engine/lib/engine/build/state.ex index e506e192..ebc31397 100644 --- a/engine/lib/engine/build/state.ex +++ b/engine/lib/engine/build/state.ex @@ -1,11 +1,10 @@ defmodule Engine.Build.State do alias Elixir.Features - alias Engine.Document - alias Engine.Project + alias Forge.Document + alias Forge.Project alias Engine.Api.Messages alias Engine.Build - alias Engine.Plugin alias Engine.VM.Versions require Logger @@ -118,7 +117,6 @@ defmodule Engine.Build.State do Engine.broadcast(compile_message) Engine.broadcast(diagnostics_message) - Plugin.diagnose(project, state.build_number) end) state @@ -176,7 +174,6 @@ defmodule Engine.Build.State do Engine.broadcast(compile_message) Engine.broadcast(diagnostics) - Plugin.diagnose(project, state.build_number, document) end) state diff --git a/engine/lib/engine/code_action.ex b/engine/lib/engine/code_action.ex index 55ceaa06..c2b14868 100644 --- a/engine/lib/engine/code_action.ex +++ b/engine/lib/engine/code_action.ex @@ -1,7 +1,7 @@ defmodule Engine.CodeAction do - alias Engine.Document - alias Engine.Document.Changes - alias Engine.Document.Range + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Document.Range alias Engine.CodeAction.Diagnostic alias Engine.CodeAction.Handlers @@ -22,7 +22,7 @@ defmodule Engine.CodeAction do title: String.t(), kind: code_action_kind, changes: Changes.t(), - uri: Engine.uri() + uri: Forge.uri() } @handlers [ @@ -33,7 +33,7 @@ defmodule Engine.CodeAction do Handlers.RemoveUnusedAlias ] - @spec new(Engine.uri(), String.t(), code_action_kind(), Changes.t()) :: t() + @spec new(Forge.uri(), String.t(), code_action_kind(), Changes.t()) :: t() def new(uri, title, kind, changes) do %__MODULE__{uri: uri, title: title, changes: changes, kind: kind} end diff --git a/engine/lib/engine/code_action/diagnostic.ex b/engine/lib/engine/code_action/diagnostic.ex index e7379210..8d4c3086 100644 --- a/engine/lib/engine/code_action/diagnostic.ex +++ b/engine/lib/engine/code_action/diagnostic.ex @@ -1,5 +1,5 @@ defmodule Engine.CodeAction.Diagnostic do - alias Engine.Document.Range + alias Forge.Document.Range defstruct [:range, :message, :source] @type message :: String.t() diff --git a/engine/lib/engine/code_action/handler.ex b/engine/lib/engine/code_action/handler.ex index fe1fae4c..d2dcbc10 100644 --- a/engine/lib/engine/code_action/handler.ex +++ b/engine/lib/engine/code_action/handler.ex @@ -1,6 +1,6 @@ defmodule Engine.CodeAction.Handler do - alias Engine.Document - alias Engine.Document.Range + alias Forge.Document + alias Forge.Document.Range alias Engine.CodeAction alias Engine.CodeAction.Diagnostic diff --git a/engine/lib/engine/code_action/handlers/add_alias.ex b/engine/lib/engine/code_action/handlers/add_alias.ex index f6dca56a..01860be4 100644 --- a/engine/lib/engine/code_action/handlers/add_alias.ex +++ b/engine/lib/engine/code_action/handlers/add_alias.ex @@ -1,11 +1,11 @@ defmodule Engine.CodeAction.Handlers.AddAlias do - alias Engine.Ast - alias Engine.Ast.Analysis - alias Engine.Ast.Analysis.Alias - alias Engine.Document - alias Engine.Document.Changes - alias Engine.Document.Position - alias Engine.Document.Range + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Alias + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Document.Position + alias Forge.Document.Range alias Engine.Formats alias Engine.Analyzer @@ -15,7 +15,6 @@ defmodule Engine.CodeAction.Handlers.AddAlias do alias Engine.Modules alias Engine.Search.Fuzzy alias Engine.Search.Indexer.Entry - alias Mix.Tasks.Namespace alias Sourceror.Zipper @behaviour CodeAction.Handler diff --git a/engine/lib/engine/code_action/handlers/organize_aliases.ex b/engine/lib/engine/code_action/handlers/organize_aliases.ex index bf662019..db9f5896 100644 --- a/engine/lib/engine/code_action/handlers/organize_aliases.ex +++ b/engine/lib/engine/code_action/handlers/organize_aliases.ex @@ -1,9 +1,9 @@ defmodule Engine.CodeAction.Handlers.OrganizeAliases do - alias Engine.Ast.Analysis - alias Engine.Ast.Analysis.Scope - alias Engine.Document - alias Engine.Document.Changes - alias Engine.Document.Range + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Scope + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Document.Range alias Engine.CodeAction alias Engine.CodeMod diff --git a/engine/lib/engine/code_action/handlers/remove_unused_alias.ex b/engine/lib/engine/code_action/handlers/remove_unused_alias.ex index 0737d695..45964d34 100644 --- a/engine/lib/engine/code_action/handlers/remove_unused_alias.ex +++ b/engine/lib/engine/code_action/handlers/remove_unused_alias.ex @@ -21,13 +21,13 @@ defmodule Engine.CodeAction.Handlers.RemoveUnusedAlias do normalizer and possibly fix sourceror, so until then, this is what we have. """ - alias Engine.Ast - alias Engine.Ast.Analysis - alias Engine.Document - alias Engine.Document.Changes - alias Engine.Document.Edit - alias Engine.Document.Position - alias Engine.Document.Range + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Document.Edit + alias Forge.Document.Position + alias Forge.Document.Range alias Engine.Analyzer alias Engine.CodeAction alias Engine.CodeAction.Diagnostic diff --git a/engine/lib/engine/code_action/handlers/replace_remote_function.ex b/engine/lib/engine/code_action/handlers/replace_remote_function.ex index 3d822a85..5a0eb1d1 100644 --- a/engine/lib/engine/code_action/handlers/replace_remote_function.ex +++ b/engine/lib/engine/code_action/handlers/replace_remote_function.ex @@ -1,9 +1,9 @@ defmodule Engine.CodeAction.Handlers.ReplaceRemoteFunction do - alias Engine.Ast - alias Engine.Document - alias Engine.Document.Changes - alias Engine.Document.Edit - alias Engine.Document.Range + alias Forge.Ast + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Document.Edit + alias Forge.Document.Range alias Engine.CodeAction alias Engine.CodeAction.Diagnostic diff --git a/engine/lib/engine/code_action/handlers/replace_with_underscore.ex b/engine/lib/engine/code_action/handlers/replace_with_underscore.ex index c9bd7728..2fdd361d 100644 --- a/engine/lib/engine/code_action/handlers/replace_with_underscore.ex +++ b/engine/lib/engine/code_action/handlers/replace_with_underscore.ex @@ -1,8 +1,8 @@ defmodule Engine.CodeAction.Handlers.ReplaceWithUnderscore do - alias Engine.Ast - alias Engine.Document - alias Engine.Document.Changes - alias Engine.Document.Range + alias Forge.Ast + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Document.Range alias Engine.CodeAction alias Engine.CodeAction.Diagnostic alias Sourceror.Zipper diff --git a/engine/lib/engine/code_intelligence/definition.ex b/engine/lib/engine/code_intelligence/definition.ex index b0f09bd2..0cb65aba 100644 --- a/engine/lib/engine/code_intelligence/definition.ex +++ b/engine/lib/engine/code_intelligence/definition.ex @@ -1,11 +1,11 @@ defmodule Engine.CodeIntelligence.Definition do alias ElixirSense.Providers.Location, as: ElixirSenseLocation alias Future.Code - alias Engine.Ast - alias Engine.Ast.Analysis - alias Engine.Document - alias Engine.Document.Location - alias Engine.Document.Position + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.Document.Location + alias Forge.Document.Position alias Engine.Formats alias Engine.CodeIntelligence.Entity alias Engine.Search.Indexer.Entry diff --git a/engine/lib/engine/code_intelligence/entity.ex b/engine/lib/engine/code_intelligence/entity.ex index dd307236..eb312a81 100644 --- a/engine/lib/engine/code_intelligence/entity.ex +++ b/engine/lib/engine/code_intelligence/entity.ex @@ -1,10 +1,10 @@ defmodule Engine.CodeIntelligence.Entity do alias Future.Code, as: Code - alias Engine.Ast - alias Engine.Ast.Analysis - alias Engine.Document - alias Engine.Document.Position - alias Engine.Document.Range + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range alias Engine.Formats alias Sourceror.Zipper diff --git a/engine/lib/engine/code_intelligence/references.ex b/engine/lib/engine/code_intelligence/references.ex index d25f68dd..e3a6ca4c 100644 --- a/engine/lib/engine/code_intelligence/references.ex +++ b/engine/lib/engine/code_intelligence/references.ex @@ -1,8 +1,8 @@ defmodule Engine.CodeIntelligence.References do - alias Engine.Ast.Analysis - alias Engine.Document - alias Engine.Document.Location - alias Engine.Document.Position + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.Document.Location + alias Forge.Document.Position alias Engine.Analyzer alias Engine.CodeIntelligence.Entity alias Engine.CodeIntelligence.Variable diff --git a/engine/lib/engine/code_intelligence/symbols.ex b/engine/lib/engine/code_intelligence/symbols.ex index b8b9108c..f1597ba7 100644 --- a/engine/lib/engine/code_intelligence/symbols.ex +++ b/engine/lib/engine/code_intelligence/symbols.ex @@ -1,6 +1,6 @@ defmodule Engine.CodeIntelligence.Symbols do - alias Engine.Document - alias Engine.Document.Range + alias Forge.Document + alias Forge.Document.Range alias Engine.CodeIntelligence.Symbols alias Engine.Search alias Engine.Search.Indexer diff --git a/engine/lib/engine/code_intelligence/symbols/document.ex b/engine/lib/engine/code_intelligence/symbols/document.ex index d1313720..6867561c 100644 --- a/engine/lib/engine/code_intelligence/symbols/document.ex +++ b/engine/lib/engine/code_intelligence/symbols/document.ex @@ -1,5 +1,5 @@ defmodule Engine.CodeIntelligence.Symbols.Document do - alias Engine.Document + alias Forge.Document alias Engine.Formats alias Engine.Search.Indexer.Entry diff --git a/engine/lib/engine/code_intelligence/symbols/workspace.ex b/engine/lib/engine/code_intelligence/symbols/workspace.ex index 40610557..415230b2 100644 --- a/engine/lib/engine/code_intelligence/symbols/workspace.ex +++ b/engine/lib/engine/code_intelligence/symbols/workspace.ex @@ -3,9 +3,9 @@ defmodule Engine.CodeIntelligence.Symbols.Workspace do defstruct [:uri, :range, :detail_range] @type t :: %__MODULE__{ - uri: Engine.uri(), - range: Engine.Document.Range.t(), - detail_range: Engine.Document.Range.t() + uri: Forge.uri(), + range: Forge.Document.Range.t(), + detail_range: Forge.Document.Range.t() } def new(uri, range, detail_range \\ nil) do @@ -13,7 +13,7 @@ defmodule Engine.CodeIntelligence.Symbols.Workspace do end end - alias Engine.Document + alias Forge.Document alias Engine.Formats alias Engine.Search.Indexer.Entry diff --git a/engine/lib/engine/code_intelligence/variable.ex b/engine/lib/engine/code_intelligence/variable.ex index e5a4a213..f7a5f836 100644 --- a/engine/lib/engine/code_intelligence/variable.ex +++ b/engine/lib/engine/code_intelligence/variable.ex @@ -1,7 +1,7 @@ defmodule Engine.CodeIntelligence.Variable do - alias Engine.Ast.Analysis - alias Engine.Document.Position - alias Engine.Document.Range + alias Forge.Ast.Analysis + alias Forge.Document.Position + alias Forge.Document.Range alias Engine.Search.Indexer alias Engine.Search.Indexer.Entry diff --git a/engine/lib/engine/code_mod/aliases.ex b/engine/lib/engine/code_mod/aliases.ex index d95c9296..5153eb62 100644 --- a/engine/lib/engine/code_mod/aliases.ex +++ b/engine/lib/engine/code_mod/aliases.ex @@ -1,12 +1,12 @@ defmodule Engine.CodeMod.Aliases do - alias Engine.Ast - alias Engine.Ast.Analysis - alias Engine.Ast.Analysis.Alias - alias Engine.Ast.Analysis.Scope - alias Engine.Document - alias Engine.Document.Edit - alias Engine.Document.Position - alias Engine.Document.Range + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Alias + alias Forge.Ast.Analysis.Scope + alias Forge.Document + alias Forge.Document.Edit + alias Forge.Document.Position + alias Forge.Document.Range alias Sourceror.Zipper diff --git a/engine/lib/engine/code_mod/diff.ex b/engine/lib/engine/code_mod/diff.ex index 94cf21a7..b175af56 100644 --- a/engine/lib/engine/code_mod/diff.ex +++ b/engine/lib/engine/code_mod/diff.ex @@ -1,9 +1,9 @@ defmodule Engine.CodeMod.Diff do alias Engine.CodeUnit - alias Engine.Document - alias Engine.Document.Edit - alias Engine.Document.Position - alias Engine.Document.Range + alias Forge.Document + alias Forge.Document.Edit + alias Forge.Document.Position + alias Forge.Document.Range @spec diff(Document.t(), String.t()) :: [Edit.t()] def diff(%Document{} = document, dest) when is_binary(dest) do diff --git a/engine/lib/engine/code_mod/format.ex b/engine/lib/engine/code_mod/format.ex index c69255fa..b7e88e8c 100644 --- a/engine/lib/engine/code_mod/format.ex +++ b/engine/lib/engine/code_mod/format.ex @@ -1,7 +1,7 @@ defmodule Engine.CodeMod.Format do - alias Engine.Document - alias Engine.Document.Changes - alias Engine.Project + alias Forge.Document + alias Forge.Document.Changes + alias Forge.Project alias Engine.Build alias Engine.CodeMod.Diff diff --git a/engine/lib/engine/commands/reindex.ex b/engine/lib/engine/commands/reindex.ex index 8ccb4aad..3c8e0c7d 100644 --- a/engine/lib/engine/commands/reindex.ex +++ b/engine/lib/engine/commands/reindex.ex @@ -1,7 +1,7 @@ defmodule Engine.Commands.Reindex do defmodule State do - alias Engine.Ast.Analysis - alias Engine.Document + alias Forge.Ast.Analysis + alias Forge.Document alias Engine.ProcessCache alias Engine.Search alias Engine.Search.Indexer @@ -70,8 +70,8 @@ defmodule Engine.Commands.Reindex do A simple genserver that prevents more than one reindexing job from running at the same time """ - alias Engine.Document - alias Engine.Project + alias Forge.Document + alias Forge.Project alias Engine.Api alias Engine.Search diff --git a/engine/lib/engine/completion.ex b/engine/lib/engine/completion.ex index 788f5ba0..79e85418 100644 --- a/engine/lib/engine/completion.ex +++ b/engine/lib/engine/completion.ex @@ -1,8 +1,8 @@ defmodule Engine.Completion do - alias Engine.Ast.Analysis - alias Engine.Ast.Env - alias Engine.Document - alias Engine.Document.Position + alias Forge.Ast.Analysis + alias Forge.Ast.Env + alias Forge.Document + alias Forge.Document.Position alias Engine.CodeMod.Format alias Engine.Completion.Candidate @@ -58,7 +58,7 @@ defmodule Engine.Completion do def struct_fields(%Analysis{} = analysis, %Position{} = position) do container_struct_module = analysis - |> Engine.Ast.cursor_path(position) + |> Forge.Ast.cursor_path(position) |> container_struct_module() with {:ok, struct_module} <- diff --git a/engine/lib/engine/convertible.ex b/engine/lib/engine/convertible.ex index b1c58dc5..85b40f06 100644 --- a/engine/lib/engine/convertible.ex +++ b/engine/lib/engine/convertible.ex @@ -1,7 +1,7 @@ defmodule Engine.Convertible.Helpers do @moduledoc false - alias Engine.Document + alias Forge.Document def apply(%{} = map, func) do result = @@ -94,14 +94,14 @@ defprotocol Engine.Convertible do UTF-16 code unit) offsets. If not handled centrally, this leads to a profusion of conversion code throughout the language server codebase. - That's where this protocol comes in. Using this protocol allows us to define native `Engine.Document.Position` and - `Engine.Document.Range` structs and have them automatically convert into their Language Server counterparts, centralizing + That's where this protocol comes in. Using this protocol allows us to define native `Forge.Document.Position` and + `Forge.Document.Range` structs and have them automatically convert into their Language Server counterparts, centralizing the conversion logic in a single pace. Note: You do not need to do conversions manually, If you define a new type, it is sufficient to implement this protocol for your new type """ - alias Engine.Document + alias Forge.Document @fallback_to_any true @@ -170,7 +170,7 @@ end defimpl Engine.Convertible, for: Any do alias Engine.Convertible - alias Engine.Document + alias Forge.Document alias Engine.Convertible.Helpers def to_native(%_struct_module{} = struct, context_document) do diff --git a/engine/lib/engine/dispatch/handlers/indexing.ex b/engine/lib/engine/dispatch/handlers/indexing.ex index e7ff0b21..7223ec57 100644 --- a/engine/lib/engine/dispatch/handlers/indexing.ex +++ b/engine/lib/engine/dispatch/handlers/indexing.ex @@ -1,5 +1,5 @@ defmodule Engine.Dispatch.Handlers.Indexing do - alias Engine.Document + alias Forge.Document alias Engine.Api.Messages alias Engine.Commands alias Engine.Dispatch diff --git a/engine/lib/engine/dispatch/pub_sub.ex b/engine/lib/engine/dispatch/pub_sub.ex index c14f6b23..e85b3583 100644 --- a/engine/lib/engine/dispatch/pub_sub.ex +++ b/engine/lib/engine/dispatch/pub_sub.ex @@ -3,7 +3,7 @@ defmodule Engine.Dispatch.PubSub do A pubsub event handler for a gen_event controller. """ defmodule State do - alias Engine.Project + alias Forge.Project defstruct [:registrations] @@ -55,7 +55,7 @@ defmodule Engine.Dispatch.PubSub do end end - alias Engine.Project + alias Forge.Project @behaviour :gen_event diff --git a/engine/lib/engine/engine.ex b/engine/lib/engine/engine.ex index 025a7f34..95fe0164 100644 --- a/engine/lib/engine/engine.ex +++ b/engine/lib/engine/engine.ex @@ -5,7 +5,7 @@ defmodule Engine do context of the remote VM. """ - alias Engine.Project + alias Forge.Project alias Engine.Api.Proxy alias Engine.CodeAction @@ -226,10 +226,4 @@ defmodule Engine do end) |> Enum.reject(&is_nil/1) end - - @typedoc "A string representation of a uri" - @type uri :: String.t() - - @typedoc "A string representation of a path on the filesystem" - @type path :: String.t() end diff --git a/engine/lib/engine/mix.ex b/engine/lib/engine/mix.ex index 27e38f1a..b8757ed7 100644 --- a/engine/lib/engine/mix.ex +++ b/engine/lib/engine/mix.ex @@ -1,5 +1,5 @@ defmodule Engine.Mix do - alias Engine.Project + alias Forge.Project def in_project(fun) do if Engine.project_node?() do diff --git a/engine/lib/engine/plugin.ex b/engine/lib/engine/plugin.ex deleted file mode 100644 index 4cfc302e..00000000 --- a/engine/lib/engine/plugin.ex +++ /dev/null @@ -1,48 +0,0 @@ -defmodule Engine.Plugin do - alias Engine.Document - alias Engine.Project - - alias Engine.Api.Messages - alias Engine.Plugin.Runner - - import Messages - - def diagnose(%Project{} = project, build_number) do - on_complete = fn - [] -> - :ok - - [_ | _] = diagnostics -> - message = - project_diagnostics( - project: project, - build_number: build_number, - diagnostics: diagnostics - ) - - Engine.broadcast(message) - end - - Runner.diagnose(project, on_complete) - end - - def diagnose(%Project{} = project, build_number, %Document{} = document) do - on_complete = fn - [] -> - :ok - - [_ | _] = diagnostics -> - message = - file_diagnostics( - project: project, - build_number: build_number, - uri: document.uri, - diagnostics: diagnostics - ) - - Engine.broadcast(message) - end - - Runner.diagnose(document, on_complete) - end -end diff --git a/engine/lib/engine/plugin/discovery.ex b/engine/lib/engine/plugin/discovery.ex deleted file mode 100644 index 0d1bece6..00000000 --- a/engine/lib/engine/plugin/discovery.ex +++ /dev/null @@ -1,73 +0,0 @@ -defmodule Engine.Plugin.Discovery do - @moduledoc """ - Discovers any plugins in any loaded applications - - This module runs through the loaded applications and checks to see if any of them are lexical plugins. - If a plugin is found, the app is then registered with the plugin system. - - If we're running in a namespaced build, we must apply the same namespace to the plugin's modules, or it - will be looking for structs like `Engine.Document`, and be passed in structs like `LXRelease.Document`, - and the plugin will crash. - """ - - alias Engine.Module.Loader - alias Engine.Plugin.Runner - alias Mix.Tasks.Namespace - - require Logger - - @namespaced_document_module [:Engine, :Document] - |> Module.concat() - |> Namespace.Module.apply() - - def run do - for {app_name, _, _} <- :application.loaded_applications(), - Runner.plugin_app?(app_name) do - load_plugin_app(app_name) - end - - Logger.info("Loaded #{inspect(Runner.enabled_plugins())}") - end - - defp load_plugin_app(app_name) do - with {:ok, modules} <- :application.get_key(app_name, :modules) do - modules - |> maybe_namespace() - |> Runner.register_all() - end - end - - defp maybe_namespace(modules) when is_list(modules) do - if namespaced?() do - Enum.each(modules, fn module -> - namespace_module(module) - unload_module(module) - Loader.ensure_loaded?(module) - end) - end - - modules - end - - defp namespace_module(module) when is_atom(module) do - module - |> :code.which() - |> List.to_string() - |> Namespace.Transform.Beams.apply() - end - - defp unload_module(module) do - unless :code.delete(module) do - :code.purge(module) - :code.delete(module) - end - end - - def namespaced_doc do - @namespaced_document_module - end - - defp namespaced? do - Loader.ensure_loaded?(@namespaced_document_module) - end -end diff --git a/engine/lib/engine/plugin/runner.ex b/engine/lib/engine/plugin/runner.ex deleted file mode 100644 index b8abe4ed..00000000 --- a/engine/lib/engine/plugin/runner.ex +++ /dev/null @@ -1,118 +0,0 @@ -defmodule Engine.Plugin.Runner do - @moduledoc false - - alias Engine.Document - alias Engine.Project - alias Engine.Module.Loader - alias Engine.Plugin.Runner - - require Logger - - @project_level_plugin_timeout_ms :timer.seconds(3) - @file_level_plugin_timeout_ms 50 - - @doc false - def clear_config do - :persistent_term.erase(__MODULE__) - end - - @doc false - def plugin_module?(module) when is_atom(module) do - function_exported?(module, :__lexical_plugin__, 0) - end - - @doc false - def plugin_app?(app_name) do - Application.get_env(app_name, lexical_prefixed_atom("plugin"), false) - end - - @doc false - def enabled_plugins do - config() - |> Map.keys() - |> Enum.map(& &1.name()) - end - - @doc false - def diagnose(%Project{} = project, on_complete) do - Runner.Coordinator.run_all( - project, - :diagnostic, - on_complete, - @project_level_plugin_timeout_ms - ) - end - - @doc false - def diagnose(%Document{} = document, on_complete) do - Runner.Coordinator.run_all(document, :diagnostic, on_complete, @file_level_plugin_timeout_ms) - end - - @doc false - def disable(plugin_module) when is_atom(plugin_module) do - Logger.error("Disabling Plugin #{plugin_module.name()} due to errors") - - config() - |> Map.delete(plugin_module) - |> write_config() - end - - @doc false - def register_all(modules) when is_list(modules) do - for module <- modules, - Loader.ensure_loaded?(module), - plugin_module?(module) do - register(module) - end - end - - @doc false - def register(plugin_module) when is_atom(plugin_module) do - current_plugins = config() - - with {:ok, plugin_type} <- fetch_plugin_type(plugin_module), - :error <- Map.fetch(current_plugins, plugin_module), - :ok <- plugin_module.init() do - current_plugins - |> Map.put(plugin_module, plugin_type) - |> write_config() - - :ok - else - error -> - Logger.warning( - "Could not register plugin #{inspect(plugin_module)} because #{inspect(error)}" - ) - - :error - end - end - - @doc false - def plugins_of_type(plugin_type) do - for {plugin_module, ^plugin_type} <- config() do - plugin_module - end - end - - defp config do - :persistent_term.get(__MODULE__, %{}) - end - - defp write_config(config) do - :persistent_term.put(__MODULE__, config) - end - - defp fetch_plugin_type(module) do - if function_exported?(module, :__plugin_type__, 0) do - {:ok, module.__plugin_type__()} - else - :error - end - end - - defp lexical_prefixed_atom(suffix) do - ("lexical_" <> suffix) - |> String.to_atom() - end -end diff --git a/engine/lib/engine/plugin/runner/coordinator.ex b/engine/lib/engine/plugin/runner/coordinator.ex deleted file mode 100644 index 31bb371b..00000000 --- a/engine/lib/engine/plugin/runner/coordinator.ex +++ /dev/null @@ -1,35 +0,0 @@ -defmodule Engine.Plugin.Runner.Coordinator do - @moduledoc false - - alias Engine.Formats - alias Engine.Plugin.Runner.Coordinator.State - - require Logger - use GenServer - - def run_all(subject, plugin_type, on_complete, timeout) when is_function(on_complete, 1) do - GenServer.call(__MODULE__, {:run_all, subject, plugin_type, on_complete, timeout}) - end - - # GenServer callbacks - - def start_link(_) do - GenServer.start_link(__MODULE__, [], name: __MODULE__) - end - - @impl GenServer - def init(_) do - {:ok, State.new()} - end - - @impl GenServer - def handle_call({:run_all, subject, plugin_type, on_complete, timeout}, _from, %State{} = state) do - {elapsed_us, {results, new_state}} = - :timer.tc(State, :run_all, [state, subject, plugin_type, timeout]) - - Logger.info("Plugins found #{length(results)} results in #{Formats.time(elapsed_us)}") - - on_complete.(results) - {:reply, :ok, new_state} - end -end diff --git a/engine/lib/engine/plugin/runner/coordinator/state.ex b/engine/lib/engine/plugin/runner/coordinator/state.ex deleted file mode 100644 index a8289f12..00000000 --- a/engine/lib/engine/plugin/runner/coordinator/state.ex +++ /dev/null @@ -1,102 +0,0 @@ -defmodule Engine.Plugin.Runner.Coordinator.State do - @moduledoc false - - alias Engine.Plugin.Runner - - defstruct tasks: [], failures: %{} - - @max_plugin_errors 10 - - require Logger - - def new do - %__MODULE__{} - end - - def run_all(%__MODULE__{} = state, subject, plugin_type, timeout) do - tasks_to_plugin_modules = - plugin_type - |> Runner.plugins_of_type() - |> Enum.map(&Runner.Supervisor.async(&1, subject)) - |> Map.new() - - await_results(state, tasks_to_plugin_modules, timeout) - end - - def failure_count(%__MODULE__{} = state, plugin_module) do - Map.get(state.failures, plugin_module, 0) - end - - def remove_task(%__MODULE__{} = state, ref) do - new_tasks = Enum.reject(state.tasks, &(&1.ref == ref)) - %__MODULE__{state | tasks: new_tasks} - end - - defp await_results(%__MODULE__{} = state, tasks_to_plugin_modules, timeout) do - raw_result = - tasks_to_plugin_modules - |> Map.keys() - |> Task.yield_many(timeout) - - {successes, failed} = - raw_result - |> Enum.reduce({[], []}, fn - {_task, {:ok, {:ok, results}}}, {successes, failures} when is_list(results) -> - {[results | successes], failures} - - {task, {:ok, {:ok, _not_list}}}, {successes, failures} -> - reason = "it did not return a list of results" - failure = {:log, task, reason} - {successes, [failure | failures]} - - {task, {:ok, reason}}, {successes, failures} -> - failure = {:log, task, reason} - {successes, [failure | failures]} - - {task, {:exit, reason}}, {successes, failures} -> - failure = {:log, task, reason} - {successes, [failure | failures]} - - {task, nil}, {successes, failures} -> - failure = {:shutdown, task} - {successes, [failure | failures]} - end) - - new_state = - Enum.reduce(failed, state, fn - {:log, %Task{} = task, reason}, state -> - plugin_module = Map.get(tasks_to_plugin_modules, task) - Logger.error("Task #{plugin_module} failed because #{inspect(reason)}") - mark_failed(state, plugin_module) - - {:shutdown, %Task{} = task}, state -> - plugin_module = Map.get(tasks_to_plugin_modules, task) - Logger.error("Task #{plugin_module} did not complete in #{timeout}ms ") - Task.shutdown(task, :brutal_kill) - mark_failed(state, plugin_module) - end) - - results = - successes - |> Enum.reverse() - |> List.flatten() - - {results, new_state} - end - - defp mark_failed(%__MODULE__{} = state, plugin_module) do - new_failures = Map.update(state.failures, plugin_module, 1, &(&1 + 1)) - maybe_shutdown(plugin_module, new_failures) - %__MODULE__{state | failures: new_failures} - end - - defp maybe_shutdown(plugin_module, failure_map) do - case Map.get(failure_map, plugin_module, 0) do - count when count >= @max_plugin_errors -> - Runner.disable(plugin_module) - - _ -> - :ok - end - end -end diff --git a/engine/lib/engine/plugin/supervisor.ex b/engine/lib/engine/plugin/supervisor.ex deleted file mode 100644 index b6fbf6f3..00000000 --- a/engine/lib/engine/plugin/supervisor.ex +++ /dev/null @@ -1,20 +0,0 @@ -defmodule Engine.Plugin.Runner.Supervisor do - @moduledoc false - - def child_spec(_) do - %{ - id: __MODULE__, - start: {Task.Supervisor, :start_link, [[name: name()]]} - } - end - - @spec async(module(), term()) :: {Task.t(), module()} - def async(plugin_module, subject) do - task = Task.Supervisor.async_nolink(name(), plugin_module, :diagnose, [subject]) - {task, plugin_module} - end - - defp name do - Module.concat(__MODULE__, TaskSupervisor) - end -end diff --git a/engine/lib/engine/port.ex b/engine/lib/engine/port.ex index 6a19406f..0e9d510b 100644 --- a/engine/lib/engine/port.ex +++ b/engine/lib/engine/port.ex @@ -3,7 +3,7 @@ defmodule Engine.Port do Utilities for launching ports in the context of a project """ - alias Engine.Project + alias Forge.Project @type open_opt :: {:env, list()} diff --git a/engine/lib/engine/project_node.ex b/engine/lib/engine/project_node.ex index 7e325b99..425885b3 100644 --- a/engine/lib/engine/project_node.ex +++ b/engine/lib/engine/project_node.ex @@ -1,5 +1,5 @@ defmodule Engine.ProjectNode do - alias Engine.Project + alias Forge.Project require Logger @@ -104,7 +104,7 @@ defmodule Engine.ProjectNode do end end - alias Engine.Document + alias Forge.Document alias Engine.ProjectNodeSupervisor use GenServer diff --git a/engine/lib/engine/project_node_supervisor.ex b/engine/lib/engine/project_node_supervisor.ex index 5efcd835..59a69af3 100644 --- a/engine/lib/engine/project_node_supervisor.ex +++ b/engine/lib/engine/project_node_supervisor.ex @@ -1,5 +1,5 @@ defmodule Engine.ProjectNodeSupervisor do - alias Engine.Project + alias Forge.Project alias Engine.ProjectNode use DynamicSupervisor diff --git a/engine/lib/engine/search/fuzzy.ex b/engine/lib/engine/search/fuzzy.ex index ed5ad4ba..9baa8a71 100644 --- a/engine/lib/engine/search/fuzzy.ex +++ b/engine/lib/engine/search/fuzzy.ex @@ -11,7 +11,7 @@ defmodule Engine.Search.Fuzzy do returned. """ - alias Engine.Project + alias Forge.Project alias Engine.Search.Fuzzy.Scorer alias Engine.Search.Indexer.Entry diff --git a/engine/lib/engine/search/indexer.ex b/engine/lib/engine/search/indexer.ex index f1cf8bee..d6bb9717 100644 --- a/engine/lib/engine/search/indexer.ex +++ b/engine/lib/engine/search/indexer.ex @@ -1,7 +1,7 @@ defmodule Engine.Search.Indexer do alias Engine.Identifier alias Engine.ProcessCache - alias Engine.Project + alias Forge.Project alias Engine.Progress alias Engine.Search.Indexer diff --git a/engine/lib/engine/search/indexer/entry.ex b/engine/lib/engine/search/indexer/entry.ex index 8363ac92..11933a15 100644 --- a/engine/lib/engine/search/indexer/entry.ex +++ b/engine/lib/engine/search/indexer/entry.ex @@ -40,9 +40,9 @@ defmodule Engine.Search.Indexer.Entry do application: module(), subject: subject(), block_id: block_id(), - block_range: Engine.Document.Range.t() | nil, + block_range: Forge.Document.Range.t() | nil, path: Path.t(), - range: Engine.Document.Range.t(), + range: Forge.Document.Range.t(), subtype: entry_subtype(), type: entry_type(), metadata: nil | map() @@ -52,7 +52,7 @@ defmodule Engine.Search.Indexer.Entry do alias Engine.Identifier alias Engine.Search.Indexer.Source.Block - alias Engine.StructAccess + alias Forge.StructAccess use StructAccess diff --git a/engine/lib/engine/search/indexer/extractors/ecto_schema.ex b/engine/lib/engine/search/indexer/extractors/ecto_schema.ex index 2bea1596..5869c605 100644 --- a/engine/lib/engine/search/indexer/extractors/ecto_schema.ex +++ b/engine/lib/engine/search/indexer/extractors/ecto_schema.ex @@ -1,6 +1,6 @@ defmodule Engine.Search.Indexer.Extractors.EctoSchema do - alias Engine.Ast - alias Engine.Document.Position + alias Forge.Ast + alias Forge.Document.Position alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Metadata diff --git a/engine/lib/engine/search/indexer/extractors/ex_unit.ex b/engine/lib/engine/search/indexer/extractors/ex_unit.ex index 0765de36..6438bc66 100644 --- a/engine/lib/engine/search/indexer/extractors/ex_unit.ex +++ b/engine/lib/engine/search/indexer/extractors/ex_unit.ex @@ -1,8 +1,8 @@ defmodule Engine.Search.Indexer.Extractors.ExUnit do - alias Engine.Ast - alias Engine.Ast.Analysis - alias Engine.Document.Position - alias Engine.Document.Range + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Document.Position + alias Forge.Document.Range alias Engine.Formats alias Engine.Analyzer alias Engine.Search.Indexer.Entry diff --git a/engine/lib/engine/search/indexer/extractors/function_definition.ex b/engine/lib/engine/search/indexer/extractors/function_definition.ex index a652acb5..fa7578b6 100644 --- a/engine/lib/engine/search/indexer/extractors/function_definition.ex +++ b/engine/lib/engine/search/indexer/extractors/function_definition.ex @@ -1,6 +1,6 @@ defmodule Engine.Search.Indexer.Extractors.FunctionDefinition do - alias Engine.Ast - alias Engine.Ast.Analysis + alias Forge.Ast + alias Forge.Ast.Analysis alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Source.Reducer diff --git a/engine/lib/engine/search/indexer/extractors/function_reference.ex b/engine/lib/engine/search/indexer/extractors/function_reference.ex index b5e426e7..87477bda 100644 --- a/engine/lib/engine/search/indexer/extractors/function_reference.ex +++ b/engine/lib/engine/search/indexer/extractors/function_reference.ex @@ -1,7 +1,7 @@ defmodule Engine.Search.Indexer.Extractors.FunctionReference do - alias Engine.Ast - alias Engine.Document.Position - alias Engine.Document.Range + alias Forge.Ast + alias Forge.Document.Position + alias Forge.Document.Range alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Extractors.FunctionDefinition diff --git a/engine/lib/engine/search/indexer/extractors/module.ex b/engine/lib/engine/search/indexer/extractors/module.ex index aefb01b6..9bf3dfd1 100644 --- a/engine/lib/engine/search/indexer/extractors/module.ex +++ b/engine/lib/engine/search/indexer/extractors/module.ex @@ -3,9 +3,9 @@ defmodule Engine.Search.Indexer.Extractors.Module do Extracts module references and definitions from AST """ - alias Engine.Ast - alias Engine.Document.Position - alias Engine.Document.Range + alias Forge.Ast + alias Forge.Document.Position + alias Forge.Document.Range alias Engine.ProcessCache alias Engine.Search.Indexer.Entry diff --git a/engine/lib/engine/search/indexer/extractors/module_attribute.ex b/engine/lib/engine/search/indexer/extractors/module_attribute.ex index 2dc4da4c..5cb4735f 100644 --- a/engine/lib/engine/search/indexer/extractors/module_attribute.ex +++ b/engine/lib/engine/search/indexer/extractors/module_attribute.ex @@ -3,8 +3,8 @@ defmodule Engine.Search.Indexer.Extractors.ModuleAttribute do Extracts module attribute definitions and references from AST """ - alias Engine.Document.Position - alias Engine.Document.Range + alias Forge.Document.Position + alias Forge.Document.Range alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Source.Reducer @@ -95,7 +95,7 @@ defmodule Engine.Search.Indexer.Extractors.ModuleAttribute do [line: start_line, column: start_column] = Sourceror.get_start_position(attr_ast) end_line = Sourceror.get_end_line(attr_ast) - {:ok, line_text} = Engine.Document.fetch_text_at(document, end_line) + {:ok, line_text} = Forge.Document.fetch_text_at(document, end_line) # add one because lsp positions are one-based end_column = String.length(line_text) + 1 diff --git a/engine/lib/engine/search/indexer/extractors/struct_definition.ex b/engine/lib/engine/search/indexer/extractors/struct_definition.ex index 6ed2deb8..cfc28882 100644 --- a/engine/lib/engine/search/indexer/extractors/struct_definition.ex +++ b/engine/lib/engine/search/indexer/extractors/struct_definition.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Indexer.Extractors.StructDefinition do - alias Engine.Ast + alias Forge.Ast alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Source.Reducer diff --git a/engine/lib/engine/search/indexer/extractors/struct_reference.ex b/engine/lib/engine/search/indexer/extractors/struct_reference.ex index 22e40d0f..00161f4d 100644 --- a/engine/lib/engine/search/indexer/extractors/struct_reference.ex +++ b/engine/lib/engine/search/indexer/extractors/struct_reference.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Indexer.Extractors.StructReference do - alias Engine.Ast + alias Forge.Ast alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Source.Reducer diff --git a/engine/lib/engine/search/indexer/extractors/variable.ex b/engine/lib/engine/search/indexer/extractors/variable.ex index d4646d9c..70ca59d1 100644 --- a/engine/lib/engine/search/indexer/extractors/variable.ex +++ b/engine/lib/engine/search/indexer/extractors/variable.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Indexer.Extractors.Variable do - alias Engine.Ast + alias Forge.Ast alias Engine.Analyzer alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Source.Reducer diff --git a/engine/lib/engine/search/indexer/quoted.ex b/engine/lib/engine/search/indexer/quoted.ex index 10de91b1..b01b8d3b 100644 --- a/engine/lib/engine/search/indexer/quoted.ex +++ b/engine/lib/engine/search/indexer/quoted.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Indexer.Quoted do - alias Engine.Ast.Analysis + alias Forge.Ast.Analysis alias Engine.ProcessCache alias Engine.Search.Indexer.Source.Reducer diff --git a/engine/lib/engine/search/indexer/source.ex b/engine/lib/engine/search/indexer/source.ex index 4ce84086..f04ac71c 100644 --- a/engine/lib/engine/search/indexer/source.ex +++ b/engine/lib/engine/search/indexer/source.ex @@ -1,6 +1,6 @@ defmodule Engine.Search.Indexer.Source do - alias Engine.Ast - alias Engine.Document + alias Forge.Ast + alias Forge.Document alias Engine.Search.Indexer require Logger diff --git a/engine/lib/engine/search/indexer/source/reducer.ex b/engine/lib/engine/search/indexer/source/reducer.ex index 29c9fba8..3b334512 100644 --- a/engine/lib/engine/search/indexer/source/reducer.ex +++ b/engine/lib/engine/search/indexer/source/reducer.ex @@ -6,8 +6,8 @@ defmodule Engine.Search.Indexer.Source.Reducer do with the AST's overall structure, and can focus on extracting content from it. """ - alias Engine.Ast.Analysis - alias Engine.Document.Position + alias Forge.Ast.Analysis + alias Forge.Document.Position alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Extractors alias Engine.Search.Indexer.Metadata diff --git a/engine/lib/engine/search/store.ex b/engine/lib/engine/search/store.ex index 8e84fcb5..4d4fa6a0 100644 --- a/engine/lib/engine/search/store.ex +++ b/engine/lib/engine/search/store.ex @@ -3,7 +3,7 @@ defmodule Engine.Search.Store do A persistent store for search entries """ - alias Engine.Project + alias Forge.Project alias Engine.Api alias Engine.Search.Indexer.Entry diff --git a/engine/lib/engine/search/store/backend.ex b/engine/lib/engine/search/store/backend.ex index 5e9edd1a..7a11857d 100644 --- a/engine/lib/engine/search/store/backend.ex +++ b/engine/lib/engine/search/store/backend.ex @@ -2,7 +2,7 @@ defmodule Engine.Search.Store.Backend do @moduledoc """ A behaviour for search store backends """ - alias Engine.Project + alias Forge.Project alias Engine.Search.Indexer.Entry @type version :: pos_integer() diff --git a/engine/lib/engine/search/store/backends/ets.ex b/engine/lib/engine/search/store/backends/ets.ex index b77a687a..d2d21dd8 100644 --- a/engine/lib/engine/search/store/backends/ets.ex +++ b/engine/lib/engine/search/store/backends/ets.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Store.Backends.Ets do - alias Engine.Project + alias Forge.Project alias Engine.Search.Indexer.Entry alias Engine.Search.Store.Backend diff --git a/engine/lib/engine/search/store/backends/ets/schema.ex b/engine/lib/engine/search/store/backends/ets/schema.ex index 89a826ab..b9d8dba4 100644 --- a/engine/lib/engine/search/store/backends/ets/schema.ex +++ b/engine/lib/engine/search/store/backends/ets/schema.ex @@ -16,7 +16,7 @@ defmodule Engine.Search.Store.Backends.Ets.Schema do quote do @behaviour unquote(__MODULE__) @version unquote(version) - alias Engine.Project + alias Forge.Project import unquote(__MODULE__), only: [defkey: 2] def version do @@ -43,7 +43,7 @@ defmodule Engine.Search.Store.Backends.Ets.Schema do end end - alias Engine.Project + alias Forge.Project alias Engine.Search.Indexer.Entry alias Engine.Search.Store.Backends.Ets.Wal diff --git a/engine/lib/engine/search/store/backends/ets/state.ex b/engine/lib/engine/search/store/backends/ets/state.ex index cd49cc6b..6ac589e3 100644 --- a/engine/lib/engine/search/store/backends/ets/state.ex +++ b/engine/lib/engine/search/store/backends/ets/state.ex @@ -5,7 +5,7 @@ defmodule Engine.Search.Store.Backends.Ets.State do This backend uses an ETS table to store its data using a schema defined in the schemas submodule. """ - alias Engine.Project + alias Forge.Project alias Engine.Search.Indexer.Entry alias Engine.Search.Store.Backends.Ets.Schema alias Engine.Search.Store.Backends.Ets.Schemas diff --git a/engine/lib/engine/search/store/backends/ets/wal.ex b/engine/lib/engine/search/store/backends/ets/wal.ex index f2157e90..c7a70daf 100644 --- a/engine/lib/engine/search/store/backends/ets/wal.ex +++ b/engine/lib/engine/search/store/backends/ets/wal.ex @@ -3,7 +3,7 @@ defmodule Engine.Search.Store.Backends.Ets.Wal do A (hopefully) simple write-ahead log """ alias Engine.Identifier - alias Engine.Project + alias Forge.Project alias Engine.VM.Versions import Record diff --git a/engine/lib/engine/search/store/state.ex b/engine/lib/engine/search/store/state.ex index 953c5dc8..df811386 100644 --- a/engine/lib/engine/search/store/state.ex +++ b/engine/lib/engine/search/store/state.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Store.State do - alias Engine.Project + alias Forge.Project alias Engine.Api.Messages alias Engine.Dispatch alias Engine.Search.Fuzzy diff --git a/engine/mix.exs b/engine/mix.exs index 55113d79..4f1f5cda 100644 --- a/engine/mix.exs +++ b/engine/mix.exs @@ -22,6 +22,7 @@ defmodule Engine.MixProject do # Run "mix help deps" to learn about dependencies. defp deps do [ + {:forge, path: "../forge"}, {:spitfire, "~> 0.1"}, {:sourceror, "~> 1.0"}, # {:gen_lsp, "~> 0.10"}, diff --git a/forge/.formatter.exs b/forge/.formatter.exs new file mode 100644 index 00000000..c3ee8ab8 --- /dev/null +++ b/forge/.formatter.exs @@ -0,0 +1,26 @@ +eventual_assertions = [ + assert_eventually: 1, + assert_eventually: 2, + refute_eventually: 1, + refute_eventually: 2 +] + +detected_assertions = [ + assert_detected: 1, + assert_detected: 2, + refute_detected: 1, + refute_detected: 2 +] + +assertions = eventual_assertions ++ detected_assertions + +[ + inputs: [ + "{mix,.formatter}.exs", + "{config,test}/**/*.{ex,exs}", + "lib/lexical/**/*.{ex,ex}", + "lib/mix/**/*.{ex,exs}" + ], + locals_without_parens: assertions, + export: [locals_without_parens: assertions] +] diff --git a/forge/.gitignore b/forge/.gitignore new file mode 100644 index 00000000..848aea9f --- /dev/null +++ b/forge/.gitignore @@ -0,0 +1,26 @@ +# The directory Mix will write compiled artifacts to. +/_build/ + +# If you run "mix test --cover", coverage assets end up here. +/cover/ + +# The directory Mix downloads your dependencies sources to. +/deps/ + +# Where third-party dependencies like ExDoc output generated docs. +/doc/ + +# Ignore .fetch files in case you like to edit your project deps locally. +/.fetch + +# If the VM crashes, it generates a dump, let's ignore it too. +erl_crash.dump + +# Also ignore archive artifacts (built via "mix archive.build"). +*.ez + +# Ignore package tarball (built via "mix hex.build"). +forge-*.tar + +# Temporary files, for example, from tests. +/tmp/ diff --git a/forge/README.md b/forge/README.md new file mode 100644 index 00000000..371ea44d --- /dev/null +++ b/forge/README.md @@ -0,0 +1,21 @@ +# Forge + +**TODO: Add description** + +## Installation + +If [available in Hex](https://hex.pm/docs/publish), the package can be installed +by adding `forge` to your list of dependencies in `mix.exs`: + +```elixir +def deps do + [ + {:forge, "~> 0.1.0"} + ] +end +``` + +Documentation can be generated with [ExDoc](https://github.com/elixir-lang/ex_doc) +and published on [HexDocs](https://hexdocs.pm). Once published, the docs can +be found at . + diff --git a/forge/lib/elixir/features.ex b/forge/lib/elixir/features.ex new file mode 100644 index 00000000..790bfb74 --- /dev/null +++ b/forge/lib/elixir/features.ex @@ -0,0 +1,42 @@ +defmodule Elixir.Features do + alias Forge.VM.Versions + + def with_diagnostics? do + function_exported?(Code, :with_diagnostics, 1) + end + + def compile_keeps_current_directory? do + Version.match?(System.version(), ">= 1.15.0") + end + + def after_verify? do + Version.match?(System.version(), ">= 1.14.0") + end + + def details_in_context? do + Version.match?(System.version(), ">= 1.16.0") + end + + def span_in_diagnostic? do + Version.match?(System.version(), ">= 1.16.0") + end + + def contains_set_theoretic_types? do + Version.match?(System.version(), ">= 1.17.0") + end + + @doc """ + Whether the `:compressed` ETS table option can be safely used. + + A bug in Erlang/OTP 27.0.0 and 27.0.1 can cause a segfault when + traversing the entire table with something like `:ets.foldl/3` if the + `:compressed` table option is used. The issue was fixed in Erlang 27.1 + + Relevant issue: https://github.com/erlang/otp/issues/8682 + """ + def can_use_compressed_ets_table? do + %{erlang: erlang_version} = Versions.to_versions(Versions.current()) + + Version.match?(erlang_version, "< 27.0.0 or >= 27.1.0") + end +end diff --git a/forge/lib/forge.ex b/forge/lib/forge.ex new file mode 100644 index 00000000..a31eec1c --- /dev/null +++ b/forge/lib/forge.ex @@ -0,0 +1,7 @@ +defmodule Forge do + @typedoc "A string representation of a uri" + @type uri :: String.t() + + @typedoc "A string representation of a path on the filesystem" + @type path :: String.t() +end diff --git a/forge/lib/forge/ast.ex b/forge/lib/forge/ast.ex new file mode 100644 index 00000000..7ba8ac8a --- /dev/null +++ b/forge/lib/forge/ast.ex @@ -0,0 +1,731 @@ +defmodule Forge.Ast do + @moduledoc """ + Utilities for analyzing Forge documents as syntax trees. + + ## Analysis + + The preferred way to use this module is by first passing a document to + `analyze/1`, which returns a `%Forge.Ast.Analysis{}` struct that + will have already parsed and analyzed a significant portion of the + document, thus reducing the cost of successive operations. + + An analysis looks at the entire AST, and thus may fail if the document + contains syntax errors that prevent parsing. To a partial analysis up + to a certain point (usually the cursor position), use `reanalyze_to/2`, + which analyzes the document up to the given position and can therefore + be used even if later parts of the document contain syntax errors. + + ## Differences from `Code` + + This module includes functions for parsing documents (`t:Forge.Document/0`) + and strings into AST's that can be used with the `Sourceror` API and + include some additional metadata. + + The structure of code parsed using this module will be slightly + different than using `Code` directly. The most notable difference is + that atoms will be wrapped in a `:__block__` node that contains + additional metadata. + + Consider these two semantically-equivalent lists, for instance: + + iex> list_with_kw_syntax = "[foo: :bar]" + iex> list_with_tuple_syntax = "[{:foo, :bar}]" + + By default, `Code.string_to_quoted/1` does not differentiate between them: + + iex> list_with_kw_syntax |> Code.string_to_quoted() + {:ok, [foo: :bar]} + + iex> list_with_tuple_syntax |> Code.string_to_quoted() + {:ok, [foo: :bar]} + + In contrast, `Forge.Ast.from/1` does: + + iex> list_with_kw_syntax |> Forge.Ast.from() + {:ok, + {:__block__, [closing: [line: 1, column: 11], line: 1, column: 1], + [ + [ + {{:__block__, [format: :keyword, line: 1, column: 2], [:foo]}, + {:__block__, [line: 1, column: 7], [:bar]}} + ] + ]}} + + iex> list_with_tuple_syntax |> Forge.Ast.from() + {:ok, + {:__block__, [closing: [line: 1, column: 14], line: 1, column: 1], + [ + [ + {:__block__, [closing: [line: 1, column: 13], line: 1, column: 2], + [ + {{:__block__, [line: 1, column: 3], [:foo]}, + {:__block__, [line: 1, column: 9], [:bar]}} + ]} + ] + ]}} + + """ + + alias Future.Code, as: Code + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.Document.Edit + alias Forge.Document.Position + alias Forge.Document.Range + alias Sourceror.Zipper + + require Logger + require Sourceror + + @typedoc "Return value from `Code.Fragment.cursor_context/2`" + @type cursor_context :: any() + + @typedoc "Return value from `Code.Fragment.surround_context/3`" + @type surround_context :: any() + + @type parse_error :: + {location :: keyword(), String.t() | {String.t(), String.t()}, String.t()} + + @type patch :: %{ + optional(:preserve_indentation) => boolean(), + range: patch_range(), + change: patch_change() + } + + @type patch_range :: %{start: patch_position(), end: patch_position()} + @type patch_position :: [patch_line | patch_column] + @type patch_line :: {:line, non_neg_integer()} + @type patch_column :: {:column, non_neg_integer()} + @type patch_change :: String.t() | (String.t() -> String.t()) + + @type short_alias :: atom() + @type alias_segments :: [short_alias] + + @type comment_metadata :: %{ + line: pos_integer(), + column: pos_integer(), + previous_eol_count: non_neg_integer(), + next_eol_count: non_neg_integer() + } + + @type position :: Position.t() | {Position.line(), Position.character()} + + @doc """ + Analyzes a document. + """ + @spec analyze(Document.t()) :: Analysis.t() + def analyze(%Document{} = document) do + document + |> from() + |> Analysis.new(document) + end + + @doc """ + Reanalyzes a document up to `position` if `analysis` is not valid. + + This can be used to analyze a fragment of an analyzed document up to + the cursor position. If the given analysis is already valid, this + function returns in unchanged. + + Note that the analysis generated for this may give invalid or incomplete + results for positions after the fragment. + + ## Examples + + iex> analysis = Ast.analyze(invalid_document) + %Ast.Analysis{valid?: false} + + iex> Ast.reanalyze_to(analysis, cursor_position) + %Ast.Analysis{} # may be valid or invalid + + """ + @spec reanalyze_to(Analysis.t(), position) :: Analysis.t() + def reanalyze_to(%Analysis{valid?: false} = analysis, position) do + %Position{} = position = normalize_position(position, analysis.document) + + analysis.document + |> fragment(position) + |> Analysis.new(analysis.document) + end + + def reanalyze_to(%Analysis{valid?: true} = analysis, _position) do + analysis + end + + @doc """ + Returns an AST generated from a valid document or string. + """ + @spec from(Document.t() | Analysis.t() | String.t()) :: + {:ok, Macro.t(), comment_metadata()} | {:error, parse_error()} + def from(%Document{} = document) do + document + |> Document.to_string() + |> from() + end + + def from(%Analysis{valid?: true} = analysis) do + comments = + analysis.comments_by_line + |> Map.values() + |> Enum.sort_by(& &1.line) + + {:ok, analysis.ast, comments} + end + + def from(%Analysis{valid?: false, parse_error: error}), do: error + + def from(s) when is_binary(s) do + do_string_to_quoted(s) + end + + @doc """ + Returns an AST fragment from the start of the document to the given position. + """ + @spec fragment(Document.t(), position) :: {:ok, Macro.t()} | {:error, parse_error()} + def fragment(%Document{} = document, position) do + # https://github.com/elixir-lang/elixir/issues/12673#issuecomment-1592845875 + # Note: because of the above issue: Using `cursor_context` + `container_cursor_to_quoted` + # can't deal with some cases like: `alias Foo.Bar, as: AnotherBar`, + # so we need to add a new line to make sure we can get the parrent node of the cursor + %{line: line} = normalize_position(position, document) + added_new_line_position = Position.new(document, line + 1, 1) + fragment = Document.fragment(document, added_new_line_position) + + case do_container_cursor_to_quoted(fragment) do + {:ok, quoted} -> + {:ok, quoted} + + _error -> + # https://github.com/elixir-lang/elixir/issues/12673#issuecomment-1626932280 + # NOTE: Adding new line doesn't always work, + # so we need to try again without adding new line + document_fragment = Document.fragment(document, position) + do_container_cursor_to_quoted(document_fragment) + end + end + + @doc """ + Parses the given fragment into an AST. + """ + @spec fragment(String.t()) :: {:ok, Macro.t()} | {:error, parse_error()} + def fragment(s) when is_binary(s) do + do_container_cursor_to_quoted(s) + end + + @doc """ + Returns the cursor context of the document at a position. + """ + @spec cursor_context(Analysis.t() | Document.t(), position) :: + {:ok, cursor_context()} | {:error, :cursor_context} + def cursor_context(%Analysis{} = analysis, position) do + cursor_context(analysis.document, position) + end + + def cursor_context(%Document{} = document, position) do + %Position{} = position = normalize_position(position, document) + + document + |> Document.fragment(position) + |> do_cursor_context() + end + + @doc """ + Returns the surround context of the document at a position. + """ + @spec surround_context(Analysis.t() | Document.t(), position) :: + {:ok, surround_context()} | {:error, :surround_context} + def surround_context(%Analysis{} = analysis, position) do + surround_context(analysis.document, position) + end + + def surround_context(%Document{} = document, position) do + %Position{} = position = normalize_position(position, document) + + document + |> Document.to_string() + |> do_surround_context(position) + end + + @doc """ + Returns the path to the innermost node in the document at the given position. + + This function differs from `cursor_path/2` in that it expects a valid + AST and the returned path will not contain a `:__cursor__` node. + """ + @spec path_at(Analysis.t() | Document.t(), position) :: + {:ok, [Macro.t(), ...]} | {:error, :not_found | parse_error()} + def path_at(%struct{} = document_or_analysis, %Position{} = position) + when struct in [Document, Analysis] do + with {:ok, ast, _} <- from(document_or_analysis) do + path_at(ast, position) + end + end + + @spec path_at(Macro.t(), Position.t()) :: + {:ok, [Macro.t(), ...]} | {:error, :not_found} + def path_at(ast, %Position{} = position) do + path = innermost_path(ast, [], &contains_position?(&1, position)) + + case path do + nil -> {:error, :not_found} + path -> {:ok, path} + end + end + + @doc """ + Returns the path to the cursor in a fragment of the document from the + start to the given position. + + This function differs from `path_at/2` in that it operates on an AST + fragment as opposed to a full AST and the call never fails, though it + may return an empty list. + """ + @spec cursor_path(Analysis.t() | Document.t(), position) :: [Macro.t()] + def cursor_path(%Analysis{} = analysis, position) do + cursor_path(analysis.document, position) + end + + def cursor_path(%Document{} = document, position) do + %Position{} = position = normalize_position(position, document) + document_fragment = Document.fragment(document, position) + + case do_container_cursor_to_quoted(document_fragment) do + {:ok, quoted} -> + quoted + |> Future.Macro.path(&match?({:__cursor__, _, _}, &1)) + |> List.wrap() + + _ -> + [] + end + end + + @doc """ + Returns a zipper for the document AST focused at the given position. + """ + @spec zipper_at(Document.t(), Position.t()) :: {:ok, Zipper.t()} | {:error, parse_error()} + def zipper_at(%Document{} = document, %Position{} = position) do + with {:ok, ast, _} <- from(document) do + zipper_at_position(ast, position) + end + end + + @doc """ + Returns whether the given AST contains a position. + """ + @spec contains_position?(Macro.t(), Position.t()) :: boolean() + def contains_position?(ast, %Position{} = position) do + case Sourceror.get_range(ast) do + %{start: start_pos, end: end_pos} -> + start_pos = {start_pos[:line], start_pos[:column]} + end_pos = {end_pos[:line], end_pos[:column]} + within?(position, start_pos, end_pos) + + nil -> + false + end + end + + @doc """ + Converts the document to a zipper and traverses the nodes on the given line. + + The given function must accept and return a (potentially modified) zipper. + To maintain an accumulator, use `traverse_line/4`. + """ + @spec traverse_line(Document.t(), Position.line(), (Zipper.t() -> Zipper.t())) :: + {:ok, Zipper.t()} | {:error, parse_error()} + def traverse_line(%Document{} = document, line_number, fun) when is_integer(line_number) do + range = one_line_range(document, line_number) + traverse_in(document, range, fun) + end + + @spec traverse_line( + Document.t(), + Position.line(), + acc, + (Zipper.t(), acc -> {Zipper.t(), acc}) + ) :: + {:ok, Zipper.t(), acc} | {:error, parse_error()} + when acc: any() + def traverse_line(%Document{} = document, line_number, acc, fun) when is_integer(line_number) do + range = one_line_range(document, line_number) + traverse_in(document, range, acc, fun) + end + + @doc """ + Converts AST patches to document edits. + + Returns `{:ok, edits}` if all patches are valid and `:error` otherwise. + """ + @spec patches_to_edits(Document.t(), [patch()]) :: {:ok, [Edit.t()]} | :error + def patches_to_edits(%Document{} = document, patches) do + maybe_edits = + Enum.reduce_while(patches, [], fn patch, edits -> + case patch_to_edit(document, patch) do + {:ok, edit} -> {:cont, [edit | edits]} + error -> {:halt, error} + end + end) + + case maybe_edits do + edits when is_list(edits) -> {:ok, Enum.reverse(edits)} + error -> error + end + end + + @doc """ + Converts a single AST patch to a document edit. + + Returns `{:ok, edit}` if valid and `:error` otherwise. + """ + @spec patch_to_edit(Document.t(), patch()) :: {:ok, Edit.t()} | :error + def patch_to_edit(%Document{} = document, %{} = patch) do + %{change: change, range: %{start: start_pos, end: end_pos}} = patch + + with {:ok, range} <- patch_to_range(document, start_pos, end_pos) do + {:ok, Edit.new(change, range)} + end + end + + # Expands aliases given the rules in the special form + # https://hexdocs.pm/elixir/1.13.4/Kernel.SpecialForms.html#__aliases__/1 + def reify_alias(current_module, [:"Elixir" | _] = reified) do + {:ok, [current_module | reified]} + end + + def reify_alias(current_module, [:__MODULE__ | rest]) do + {:ok, [current_module | rest]} + end + + def reify_alias(current_module, [atom | _rest] = reified) when is_atom(atom) do + {:ok, [current_module | reified]} + end + + def reify_alias(current_module, [unreified | rest]) do + env = %Macro.Env{module: current_module} + + case Macro.expand(unreified, env) do + module when is_atom(module) -> {:ok, [module | rest]} + _ -> :error + end + end + + def reify_alias(current_module, []) do + {:ok, List.wrap(current_module)} + end + + @doc """ + Walks a quoted expression with an accumulator, applying `fun` to each + var or pinned var. + + Returns a tuple where the first element is the potentially modified + expression and the second is the accumulator. + """ + # Adapted from `ExUnit.Assertions.collect_vars_from_pattern/1`, + # licensed under Apache License 2.0: + # https://github.com/elixir-lang/elixir/blob/1e914b04b46125b3b9b251b64ee04380e523afc4/lib/ex_unit/lib/ex_unit/assertions.ex#L657 + @spec prewalk_vars(Macro.t(), acc, (Macro.t(), acc -> {Macro.t(), acc})) :: {Macro.t(), acc} + when acc: term() + def prewalk_vars(ast, acc, fun) do + {ast, {acc, _}} = + Macro.prewalk(ast, {acc, false}, fn + # <> + # ^^^^^^^^^^^ + {:"::", meta, [left, right]}, {acc, _prev_pinned?} -> + {right, acc} = prewalk_vars_in_binary(right, acc, fun) + {{:"::", meta, [left, right]}, {acc, false}} + + # skip vars inside quote or @ + {skip, _, [_]} = node, {acc, _prev_pinned?} when skip in [:@, :quote] -> + {node, {acc, false}} + + # skip _ + {:_, _, context} = node, {acc, _prev_pinned?} when is_atom(context) -> + {node, {acc, false}} + + # ^pinned + # emit the pinned var and set prev_pinned? so the var isn't omitted + # immediately after + {:^, _, [{name, _, context}]} = pinned, {acc, _prev_pinned?} + when is_atom(name) and is_atom(context) -> + {pinned, acc} = fun.(pinned, acc) + {pinned, {acc, true}} + + # var + {name, _, context} = var, {acc, false} when is_atom(name) and is_atom(context) -> + {var, acc} = fun.(var, acc) + {var, {acc, false}} + + # skip everything else + node, {acc, _prev_pinned?} -> + {node, {acc, false}} + end) + + {ast, acc} + end + + defp prewalk_vars_in_binary(right, acc, fun) do + Macro.prewalk(right, acc, fn + {mode, mode_meta, [{name, _, context} = var]}, acc + when is_atom(mode) and is_atom(name) and is_atom(context) -> + {var, acc} = fun.(var, acc) + {{mode, mode_meta, [var]}, acc} + + node, acc -> + {node, acc} + end) + end + + @doc """ + Returns whether a var with `name` and `context` is in `vars`. + """ + def has_var?(vars, name, context) do + Enum.any?(vars, &match?({^name, _, ^context}, &1)) + end + + # private + + defp do_string_to_quoted(string) when is_binary(string) do + Code.string_to_quoted_with_comments(string, + literal_encoder: &{:ok, {:__block__, &2, [&1]}}, + token_metadata: true, + columns: true, + unescape: false + ) + end + + defp do_container_cursor_to_quoted(fragment) when is_binary(fragment) do + Code.Fragment.container_cursor_to_quoted(fragment, + literal_encoder: &{:ok, {:__block__, &2, [&1]}}, + token_metadata: true, + columns: true, + unescape: false + ) + end + + defp do_cursor_context(fragment) when is_binary(fragment) do + case Code.Fragment.cursor_context(fragment) do + :none -> {:error, :cursor_context} + context -> {:ok, context} + end + end + + defp do_surround_context(fragment, %Position{} = position) when is_binary(fragment) do + pos = {position.line, position.character} + + case Code.Fragment.surround_context(fragment, pos) do + :none -> do_surround_context_again(fragment, pos) + context -> {:ok, context} + end + end + + defp do_surround_context_again(_fragment, {_line, 1} = _position) do + {:error, :surround_context} + end + + defp do_surround_context_again(fragment, {line, column} = position) do + case Code.Fragment.surround_context(fragment, {line, column - 1}) do + :none -> + {:error, :surround_context} + + context -> + if context.end == position do + {:ok, context} + else + {:error, :surround_context} + end + end + end + + defp patch_to_range(document, start_pos, end_pos) do + with {:ok, start_pos} <- patch_to_position(document, start_pos), + {:ok, end_pos} <- patch_to_position(document, end_pos) do + {:ok, Range.new(start_pos, end_pos)} + end + end + + defp patch_to_position(document, patch_keyword) do + with {:ok, line} <- Keyword.fetch(patch_keyword, :line), + {:ok, column} <- Keyword.fetch(patch_keyword, :column) do + {:ok, Position.new(document, line, column)} + end + end + + defp zipper_at_position(ast, position) do + zipper = + ast + |> Zipper.zip() + |> Zipper.find(fn node -> + at_or_after?(node, position) + end) + + if zipper do + {:ok, zipper} + else + {:error, :not_found} + end + end + + # in the future, I'd like to expose functions that only traverse a section of the document, + # but presently, traverse only follows a subtree, so it won't work for our purposes + defp traverse_in(%Document{} = document, %Range{} = range, fun) do + ignore_acc = fn node, acc -> + {fun.(node), acc} + end + + case traverse_in(document, range, [], ignore_acc) do + {:ok, zipper, _} -> + {:ok, zipper} + + error -> + error + end + end + + defp traverse_in(%Document{} = document, %Range{} = range, acc, fun) do + with {:ok, zipper} <- zipper_at(document, range.start) do + {zipper, {_position, acc}} = + Zipper.traverse_while( + zipper, + {{0, 0}, acc}, + fn %Zipper{node: node} = zipper, {last_position, acc} -> + current_position = node_position(node, last_position) + + if within?(current_position, range.start, range.end) do + {zipper, new_acc} = fun.(zipper, acc) + + {:cont, zipper, {current_position, new_acc}} + else + {:skip, zipper, {current_position, acc}} + end + end + ) + + {:ok, zipper, acc} + end + end + + defp within?(pos, start_pos, end_pos) do + Position.compare(pos, start_pos) in [:gt, :eq] and + Position.compare(pos, end_pos) in [:lt, :eq] + end + + defp at_or_after?(node, %Position{} = position) do + node_position = node_position(node, {0, 0}) + + Position.compare(node_position, position) in [:gt, :eq] + end + + defp one_line_range(%Document{} = document, line_number) do + start_pos = Position.new(document, line_number, 1) + end_pos = Position.new(document, line_number + 1, 0) + Range.new(start_pos, end_pos) + end + + defp node_position(node, {line, column}) do + {get_line(node, line), get_column(node, column)} + end + + defp get_line([{:do, node}], default) do + get_line(node, default) + end + + defp get_line({:do, node}, default) do + get_line(node, default) + end + + defp get_line(node, default) when is_tuple(node) and tuple_size(node) == 3 do + Sourceror.get_line(node, default) + end + + defp get_line(_, default) do + default + end + + defp get_column([do: node], default) do + get_column(node, default) + end + + defp get_column({:do, node}, default) do + get_column(node, default) + end + + defp get_column(node, default) when is_tuple(node) and tuple_size(node) == 3 do + Sourceror.get_column(node, default) + end + + defp get_column(_, default) do + default + end + + # Similar to `Future.Macro.path/3`, but returns the path to the innermost + # node for which `fun` returns truthy instead of the path to the first node + # that returns such. + defp innermost_path(ast, acc, fun) + + defp innermost_path({form, _, args} = ast, acc, fun) when is_atom(form) do + acc = [ast | acc] + + if fun.(ast) do + innermost_path_args(args, acc, fun) || acc + else + innermost_path_args(args, acc, fun) + end + end + + defp innermost_path({form, _meta, args} = ast, acc, fun) do + acc = [ast | acc] + + if fun.(ast) do + innermost_path(form, acc, fun) || innermost_path_args(args, acc, fun) || acc + else + innermost_path(form, acc, fun) || innermost_path_args(args, acc, fun) + end + end + + defp innermost_path({left, right} = ast, acc, fun) do + acc = [ast | acc] + + if fun.(ast) do + innermost_path(left, acc, fun) || innermost_path(right, acc, fun) || acc + else + innermost_path(left, acc, fun) || innermost_path(right, acc, fun) + end + end + + defp innermost_path(list, acc, fun) when is_list(list) do + acc = [list | acc] + + if fun.(list) do + innermost_path_list(list, acc, fun) || acc + else + innermost_path_list(list, acc, fun) + end + end + + defp innermost_path(ast, acc, fun) do + if fun.(ast) do + [ast | acc] + end + end + + defp innermost_path_args(atom, _acc, _fun) when is_atom(atom), do: nil + + defp innermost_path_args(list, acc, fun) when is_list(list) do + innermost_path_list(list, acc, fun) + end + + defp innermost_path_list([], _acc, _fun) do + nil + end + + defp innermost_path_list([arg | args], acc, fun) do + innermost_path(arg, acc, fun) || innermost_path_list(args, acc, fun) + end + + defp normalize_position(%Position{} = position, _document), do: position + + defp normalize_position({line, character}, %Document{} = document) do + Position.new(document, line, character) + end +end diff --git a/forge/lib/forge/ast/analysis.ex b/forge/lib/forge/ast/analysis.ex new file mode 100644 index 00000000..e2ecd2a8 --- /dev/null +++ b/forge/lib/forge/ast/analysis.ex @@ -0,0 +1,539 @@ +defmodule Forge.Ast.Analysis do + @moduledoc """ + A data structure representing an analyzed AST. + + See `Forge.Ast.analyze/1`. + """ + + alias Forge.Ast.Analysis.Alias + alias Forge.Ast.Analysis.Import + alias Forge.Ast.Analysis.Require + alias Forge.Ast.Analysis.Scope + alias Forge.Ast.Analysis.State + alias Forge.Ast.Analysis.Use + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Identifier + alias Sourceror.Zipper + + defstruct [:ast, :document, :parse_error, scopes: [], comments_by_line: %{}, valid?: true] + + @type t :: %__MODULE__{} + @scope_id :_scope_id + + @block_keywords [:do, :else, :rescue, :catch, :after] + @clauses [:->] + + @doc false + def new(parse_result, document) + + def new({:ok, ast}, %Document{} = document) do + new({:ok, ast, []}, document) + end + + def new({:ok, ast, comments}, %Document{} = document) do + scopes = traverse(ast, document) + comments_by_line = Map.new(comments, fn comment -> {comment.line, comment} end) + + %__MODULE__{ + ast: ast, + document: document, + scopes: scopes, + comments_by_line: comments_by_line + } + end + + def new(error, document) do + %__MODULE__{ + document: document, + parse_error: error, + valid?: false + } + end + + @doc """ + Returns the scopes for the given position, sorted by nearest proximity. + """ + def scopes_at(%__MODULE__{scopes: scopes}, %Position{} = position) do + scopes + |> Enum.filter(fn %Scope{range: range} = scope -> + scope.id == :global or Range.contains?(range, position) + end) + |> Enum.sort_by( + fn + %Scope{id: :global} -> 0 + %Scope{range: range} -> {range.start.line, range.start.character} + end, + :desc + ) + end + + @doc false + def scope_id({_, meta, _}) when is_list(meta) do + Keyword.get(meta, @scope_id) + end + + def scope_id({left, right}) do + {scope_id(left), scope_id(right)} + end + + def scope_id(list) when is_list(list) do + Enum.map(list, &scope_id/1) + end + + def scope_id(_) do + nil + end + + def commented?(%__MODULE__{} = analysis, %Position{} = position) do + case Map.fetch(analysis.comments_by_line, position.line) do + {:ok, comment} -> position.character > comment[:column] + _ -> false + end + end + + @doc """ + Returns the scope of the nearest enclosing module of the given function. + + If there is no enclosing module scope, the global scope is returned + """ + @spec module_scope(t(), Range.t()) :: Scope.t() + def module_scope(%__MODULE__{} = analysis, %Range{} = range) do + enclosing_scopes = + analysis + |> scopes_at(range.start) + |> enclosing_scopes(range) + + first_scope = List.first(enclosing_scopes) + + Enum.reduce_while(enclosing_scopes, first_scope, fn + %Scope{module: same} = current, %Scope{module: same} -> + {:cont, current} + + _, current -> + {:halt, current} + end) + end + + defp enclosing_scopes(scopes, range) do + Enum.filter(scopes, fn scope -> + Range.contains?(scope.range, range.start) + end) + end + + defp traverse(quoted, %Document{} = document) do + quoted = preprocess(quoted) + + {_, state} = + Macro.traverse( + quoted, + State.new(document), + fn quoted, state -> + case analyze_node(quoted, state) do + {new_quoted, new_state} -> + {new_quoted, new_state} + + new_state -> + {quoted, new_state} + end + end, + fn quoted, state -> + case {scope_id(quoted), State.current_scope(state)} do + {id, %Scope{id: id}} -> + {quoted, State.pop_scope(state)} + + _ -> + {quoted, state} + end + end + ) + + unless length(state.scopes) == 1 do + raise RuntimeError, + "invariant not met, :scopes should only contain the global scope: #{inspect(state)}" + end + + state + # pop the final, global state + |> State.pop_scope() + |> Map.fetch!(:visited) + |> Map.reject(fn {_id, scope} -> Scope.empty?(scope) end) + |> correct_ranges(quoted, document) + |> Map.values() + end + + defp preprocess(quoted) do + Macro.prewalk(quoted, &with_scope_id/1) + end + + defp correct_ranges(scopes, quoted, document) do + {_zipper, scopes} = + quoted + |> Zipper.zip() + |> Zipper.traverse(scopes, fn %Zipper{node: node} = zipper, scopes -> + id = scope_id(node) + + if scope = scopes[id] do + {zipper, Map.put(scopes, id, maybe_correct_range(scope, zipper, document))} + else + {zipper, scopes} + end + end) + + scopes + end + + # extend range for block pairs to either the beginning of their next + # sibling or, if they are the last element, the end of their parent + defp maybe_correct_range(scope, %Zipper{node: {_, _}} = zipper, %Document{} = document) do + with %Zipper{node: sibling} <- Zipper.right(zipper), + %{start: sibling_start} <- Sourceror.get_range(sibling) do + new_end = Position.new(document, sibling_start[:line], sibling_start[:column]) + put_in(scope.range.end, new_end) + else + _ -> + # we go up twice to get to the real parent because ast pairs + # are always in a list + %Zipper{node: parent} = zipper |> Zipper.up() |> Zipper.up() + + case Sourceror.get_range(parent) do + %{end: parent_end} -> + new_end = Position.new(document, parent_end[:line], parent_end[:column]) + put_in(scope.range.end, new_end) + + _ -> + scope + end + end + end + + defp maybe_correct_range(scope, _zipper, _document) do + scope + end + + # add a unique ID to 3-element tuples + defp with_scope_id({_, _, _} = quoted) do + id = Identifier.next_global!() + Macro.update_meta(quoted, &Keyword.put(&1, @scope_id, id)) + end + + defp with_scope_id(quoted) do + quoted + end + + @skip :skipped? + + defp skip_leading_do({_, meta, _} = root_ast) do + # Marks the first do block after the passed in node. This is because + # that do block doesn't have accurate ending information, and if we build + # a scope around it, it won't end properly, which will cause information + # contained in scopes to leak out of them. + + case Keyword.fetch(meta, :do) do + {:ok, [line: line, column: column]} -> + Macro.prewalk(root_ast, fn + {:__block__, _meta, [:do]} = block_ast -> + case Sourceror.get_start_position(block_ast) do + [line: ^line, column: ^column] -> + skip(block_ast) + + _ -> + block_ast + end + + other -> + other + end) + + _ -> + root_ast + end + end + + defp skip({_, _, _} = quoted) do + Macro.update_meta(quoted, &Keyword.put(&1, @skip, true)) + end + + defp skipped?({_, meta, _}) when is_list(meta) do + skipped?(meta) + end + + defp skipped?(meta) when is_list(meta) do + Keyword.get(meta, @skip, false) + end + + defp skipped?(_), do: false + + @module_defining_forms [:defmodule, :defprotocol] + # defmodule Foo do or defprotocol MyProtocol do + defp analyze_node({form, _meta, [{:__aliases__, _, segments} | _]} = quoted, state) + when form in @module_defining_forms do + module = + case State.current_module(state) do + [] -> segments + current_module -> reify_alias(current_module, segments) + end + + current_module_alias = Alias.implicit(state.document, quoted, module, :__MODULE__) + + new_state = + state + # implicit alias belongs to the current scope + |> maybe_push_implicit_alias(segments, state.document, quoted) + # new __MODULE__ alias belongs to the new scope + |> State.push_scope_for(quoted, module) + |> State.push_alias(current_module_alias) + + {skip_leading_do(quoted), new_state} + end + + # defimpl Foo, for: SomeProtocol do + defp analyze_node( + {:defimpl, _meta, + [ + {:__aliases__, _, protocol_segments}, + [{_for_keyword, {:__aliases__, _, for_segments}}] | _ + ]} = quoted, + state + ) do + expanded_for = expand_alias(for_segments, state) + module = expand_alias(protocol_segments ++ expanded_for, state) + current_module_alias = Alias.implicit(state.document, quoted, module, :__MODULE__) + for_alias = Alias.implicit(state.document, quoted, expanded_for, :"@for") + protocol_alias = Alias.implicit(state.document, quoted, protocol_segments, :"@protocol") + + new_state = + state + |> State.push_scope_for(quoted, module) + |> State.push_alias(current_module_alias) + |> State.push_alias(for_alias) + |> State.push_alias(protocol_alias) + + {skip_leading_do(quoted), new_state} + end + + # alias Foo.{Bar, Baz, Buzz.Qux} + defp analyze_node( + {:alias, _meta, [{{:., _, [aliases, :{}]}, _, aliases_nodes}]} = quoted, + state + ) do + base_segments = expand_alias(aliases, state) + + Enum.reduce(aliases_nodes, state, fn {:__aliases__, _, segments}, state -> + alias = + Alias.explicit(state.document, quoted, base_segments ++ segments, List.last(segments)) + + State.push_alias(state, alias) + end) + end + + # alias Foo + # alias Foo.Bar + # alias __MODULE__.Foo + defp analyze_node({:alias, _meta, [aliases]} = quoted, state) do + case expand_alias(aliases, state) do + [_ | _] = segments -> + alias = Alias.explicit(state.document, quoted, segments, List.last(segments)) + State.push_alias(state, alias) + + [] -> + state + end + end + + # alias Foo, as: Bar + defp analyze_node({:alias, meta, [aliases, options]} = quoted, state) do + with {:ok, alias_as} <- fetch_alias_as(options), + [_ | _] = segments <- expand_alias(aliases, state) do + alias = Alias.explicit(state.document, quoted, segments, alias_as) + State.push_alias(state, alias) + else + _ -> + analyze_node({:alias, meta, [aliases]}, state) + end + end + + # import with selector import MyModule, only: :functions + defp analyze_node( + {:import, _meta, [{:__aliases__, _aliases, module}, selector]} = quoted, + state + ) do + State.push_import(state, Import.new(state.document, quoted, module, selector)) + end + + # wholesale import import MyModule + defp analyze_node({:import, _meta, [{:__aliases__, _aliases, module}]} = quoted, state) do + State.push_import(state, Import.new(state.document, quoted, module)) + end + + # require MyModule, as: Alias + defp analyze_node({:require, _meta, [{:__aliases__, _, module}, options]} = quoted, state) do + case fetch_alias_as(options) do + {:ok, as_module} -> + State.push_require(state, Require.new(state.document, quoted, module, as_module)) + + :error -> + state + end + end + + # require MyModule + defp analyze_node( + {:require, _meta, [{:__aliases__, _, module}]} = quoted, + state + ) do + State.push_require(state, Require.new(state.document, quoted, module)) + end + + # use MyModule + defp analyze_node( + {:use, _meta, [{:__aliases__, _, module} | opts]} = use, + state + ) do + State.push_use(state, Use.new(state.document, use, module, opts)) + end + + # stab clauses: -> + defp analyze_node({clause, _, _} = quoted, state) when clause in @clauses do + maybe_push_scope_for(state, quoted) + end + + # blocks: do, else, etc. + defp analyze_node({{:__block__, meta, [block]}, _} = quoted, state) + when block in @block_keywords do + if skipped?(meta) do + state + else + maybe_push_scope_for(state, quoted) + end + end + + # catch-all + defp analyze_node(_quoted, state) do + state + end + + defp maybe_push_implicit_alias(%State{} = state, [first_segment | _], document, quoted) + when is_atom(first_segment) do + segments = + case State.current_module(state) do + # the head element of top-level modules can be aliased, so we + # must expand them + [] -> + expand_alias([first_segment], state) + + # if we have a current module, we prefix the first segment with it + current_module -> + current_module ++ [first_segment] + end + + implicit_alias = Alias.implicit(document, quoted, segments, first_segment) + State.push_alias(state, implicit_alias) + end + + # don't create an implicit alias if the module is defined using complex forms: + # defmodule __MODULE__.Foo do + # defmodule unquote(...) do + defp maybe_push_implicit_alias(%State{} = state, [non_atom | _], _, _) + when not is_atom(non_atom) do + state + end + + defp expand_alias({:__MODULE__, _, nil}, state) do + State.current_module(state) + end + + defp expand_alias({:__aliases__, _, segments}, state) do + expand_alias(segments, state) + end + + defp expand_alias([{:__MODULE__, _, nil} | segments], state) do + State.current_module(state) ++ segments + end + + defp expand_alias([first | rest], state) do + alias_map = state |> State.current_scope() |> Scope.alias_map() + + case alias_map do + %{^first => existing_alias} -> + existing_alias.module ++ rest + + _ -> + [first | rest] + end + end + + defp expand_alias(quoted, state) do + reify_alias(State.current_module(state), List.wrap(quoted)) + end + + # Expands aliases given the rules in the special form + # https://hexdocs.pm/elixir/1.13.4/Kernel.SpecialForms.html#__aliases__/1 + + # When the head element is the atom :"Elixir", no expansion happens + defp reify_alias(_, [:"Elixir" | _] = reified) do + reified + end + + # Without a current module, we can't expand a non-atom head element + defp reify_alias([], [non_atom | rest]) when not is_atom(non_atom) do + rest + end + + # With no current module and an atom head, no expansion occurs + defp reify_alias([], [atom | _] = reified) when is_atom(atom) do + reified + end + + # Expand current module + defp reify_alias(current_module, [{:__MODULE__, _, nil} | rest]) do + current_module ++ rest + end + + # With a current module and an atom head, the alias is nested in the + # current module + defp reify_alias(current_module, [atom | _rest] = reified) when is_atom(atom) do + current_module ++ reified + end + + # In other cases, attempt to expand the unreified head element + defp reify_alias(current_module, [unreified | rest]) do + module = Module.concat(current_module) + env = %Macro.Env{module: module} + reified = Macro.expand(unreified, env) + + if is_atom(reified) do + reified_segments = reified |> Module.split() |> Enum.map(&String.to_atom/1) + reified_segments ++ rest + else + rest + end + end + + defp fetch_alias_as(options) when is_list(options) do + alias_as = + Enum.find_value(options, fn + {{:__block__, _, [:as]}, {:__aliases__, _, [alias_as]}} -> alias_as + _ -> nil + end) + + case alias_as do + nil -> :error + _ -> {:ok, alias_as} + end + end + + # When the `as` section is incomplete, like: `alias Foo, a` + defp fetch_alias_as(_) do + :error + end + + defp maybe_push_scope_for(%State{} = state, ast) do + if skipped?(ast) do + state + else + State.maybe_push_scope_for(state, ast) + end + end +end diff --git a/forge/lib/forge/ast/analysis/alias.ex b/forge/lib/forge/ast/analysis/alias.ex new file mode 100644 index 00000000..ca46f60b --- /dev/null +++ b/forge/lib/forge/ast/analysis/alias.ex @@ -0,0 +1,52 @@ +defmodule Forge.Ast.Analysis.Alias do + alias Forge.Ast + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + + defstruct [:module, :as, :range, explicit?: true] + + @type t :: %__MODULE__{ + module: [atom], + as: module(), + range: Range.t() | nil + } + + def explicit(%Document{} = document, ast, module, as) when is_list(module) do + range = range_for_ast(document, ast, module, as) + %__MODULE__{module: module, as: as, range: range} + end + + def implicit(%Document{} = document, ast, module, as) when is_list(module) do + range = implicit_range(document, ast) + %__MODULE__{module: module, as: as, range: range, explicit?: false} + end + + def to_module(%__MODULE__{} = alias) do + Module.concat(alias.module) + end + + @implicit_aliases [:__MODULE__, :"@for", :"@protocol"] + defp range_for_ast(document, ast, _alias, as) when as in @implicit_aliases do + implicit_range(document, ast) + end + + defp range_for_ast(document, ast, _alias, _as) do + # All other kinds of aliases defined with the `alias` special form + Ast.Range.get(ast, document) + end + + defp implicit_range(%Document{} = document, ast) do + # There are kinds of aliases that are automatically generated by elixir + # such as __MODULE__, these don't really have any code that defines them, + with [line: line, column: _] <- Sourceror.get_start_position(ast), + {:ok, line_text} <- Document.fetch_text_at(document, line) do + line_length = String.length(line_text) + alias_start = Position.new(document, line, line_length) + Range.new(alias_start, alias_start) + else + _ -> + nil + end + end +end diff --git a/forge/lib/forge/ast/analysis/import.ex b/forge/lib/forge/ast/analysis/import.ex new file mode 100644 index 00000000..d541cf2b --- /dev/null +++ b/forge/lib/forge/ast/analysis/import.ex @@ -0,0 +1,92 @@ +defmodule Forge.Ast.Analysis.Import do + alias Forge.Ast + alias Forge.Document + alias Forge.Document.Range + + defstruct module: nil, selector: :all, range: nil, explicit?: true + + @type function_name :: atom() + @type function_arity :: {function_name(), arity()} + @type selector :: + :functions + | :macros + | :sigils + | [only: [function_arity()]] + | [except: [function_arity()]] + @type t :: %{ + module: module(), + selector: selector(), + line: non_neg_integer() + } + def new(%Document{} = document, ast, module) do + %__MODULE__{module: module, range: Ast.Range.get(ast, document)} + end + + def new(%Document{} = document, ast, module, selector) do + %__MODULE__{ + module: module, + selector: expand_selector(selector), + range: Ast.Range.get(ast, document) + } + end + + def implicit(%Range{} = range, module) do + %__MODULE__{module: module, range: range, explicit?: false} + end + + defp expand_selector(selectors) when is_list(selectors) do + selectors = + Enum.reduce(selectors, [], fn + {{:__block__, _, [type]}, {:__block__, _, [selector]}}, acc + when type in [:only, :except] -> + expanded = + case selector do + :functions -> + :functions + + :macros -> + :macros + + :sigils -> + :sigils + + keyword when is_list(keyword) -> + keyword + |> Enum.reduce([], &expand_function_keywords/2) + |> Enum.reverse() + + _ -> + # they're likely in the middle of typing in something, and have produced an + # invalid import + [] + end + + [{type, expanded} | acc] + + _, acc -> + acc + end) + + if selectors == [] do + :all + else + selectors + end + end + + # If the selectors is not valid, like: `import SomeModule, o `, we default to :all + defp expand_selector(_) do + :all + end + + defp expand_function_keywords( + {{:__block__, _, [function_name]}, {:__block__, _, [arity]}}, + acc + ) + when is_atom(function_name) and is_number(arity) do + [{function_name, arity} | acc] + end + + defp expand_function_keywords(_ignored, acc), + do: acc +end diff --git a/forge/lib/forge/ast/analysis/require.ex b/forge/lib/forge/ast/analysis/require.ex new file mode 100644 index 00000000..9d0240f0 --- /dev/null +++ b/forge/lib/forge/ast/analysis/require.ex @@ -0,0 +1,10 @@ +defmodule Forge.Ast.Analysis.Require do + alias Forge.Ast + alias Forge.Document + defstruct [:module, :as, :range] + + def new(%Document{} = document, ast, module, as \\ nil) when is_list(module) do + range = Ast.Range.get(ast, document) + %__MODULE__{module: module, as: as || module, range: range} + end +end diff --git a/forge/lib/forge/ast/analysis/scope.ex b/forge/lib/forge/ast/analysis/scope.ex new file mode 100644 index 00000000..6304127c --- /dev/null +++ b/forge/lib/forge/ast/analysis/scope.ex @@ -0,0 +1,86 @@ +defmodule Forge.Ast.Analysis.Scope do + alias Forge.Ast.Analysis.Alias + alias Forge.Document.Position + alias Forge.Document.Range + + defstruct [ + :id, + :range, + module: [], + aliases: [], + imports: [], + requires: [], + uses: [] + ] + + @type import_mfa :: {module(), atom(), non_neg_integer()} + @type scope_position :: Position.t() | Position.line() | :end + + @type t :: %__MODULE__{ + id: any(), + range: Range.t(), + module: [atom()], + aliases: [Alias.t()], + imports: [import_mfa()] + } + + def new(%__MODULE__{} = parent_scope, id, %Range{} = range, module \\ []) do + uses = + if module == parent_scope.module do + # if we're still in the same module, we have the same uses + parent_scope.uses + else + [] + end + + %__MODULE__{ + id: id, + aliases: parent_scope.aliases, + imports: parent_scope.imports, + requires: parent_scope.requires, + module: module, + range: range, + uses: uses + } + end + + def global(%Range{} = range) do + %__MODULE__{id: :global, range: range} + end + + @spec alias_map(t(), scope_position()) :: %{module() => t()} + def alias_map(%__MODULE__{} = scope, position \\ :end) do + scope.aliases + # sorting by line ensures that aliases on later lines + # override aliases on earlier lines + |> Enum.sort_by(& &1.range.start.line) + |> Enum.take_while(fn %Alias{range: alias_range} -> + case position do + %Position{} = pos -> + pos.line >= alias_range.start.line + + line when is_integer(line) -> + line >= alias_range.start.line + + :end -> + true + end + end) + |> Map.new(&{&1.as, &1}) + end + + def fetch_alias_with_prefix(%__MODULE__{} = scope, prefix) do + case Enum.find(scope.aliases, fn %Alias{} = alias -> alias.as == prefix end) do + %Alias{} = existing -> {:ok, existing} + _ -> :error + end + end + + def empty?(%__MODULE__{id: :global}), do: false + def empty?(%__MODULE__{aliases: [], imports: []}), do: true + def empty?(%__MODULE__{}), do: false + + def end_line(%__MODULE__{} = scope, :end), do: scope.range.end.line + def end_line(_, %Position{} = position), do: position.line + def end_line(_, line) when is_integer(line), do: line +end diff --git a/forge/lib/forge/ast/analysis/state.ex b/forge/lib/forge/ast/analysis/state.ex new file mode 100644 index 00000000..5972d3ad --- /dev/null +++ b/forge/lib/forge/ast/analysis/state.ex @@ -0,0 +1,180 @@ +defmodule Forge.Ast.Analysis.State do + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Alias + alias Forge.Ast.Analysis.Import + alias Forge.Ast.Analysis.Require + alias Forge.Ast.Analysis.Scope + alias Forge.Ast.Analysis.Use + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + + defstruct [:document, scopes: [], visited: %{}] + + def new(%Document{} = document) do + state = %__MODULE__{document: document} + + scope = + document + |> global_range() + |> Scope.global() + + push_scope(state, scope) + end + + def current_scope(%__MODULE__{scopes: [scope | _]}), do: scope + + def current_module(%__MODULE__{} = state) do + current_scope(state).module + end + + def push_scope(%__MODULE__{} = state, %Scope{} = scope) do + Map.update!(state, :scopes, &[scope | &1]) + end + + def push_scope(%__MODULE__{} = state, id, %Range{} = range, module) when is_list(module) do + scope = + state + |> current_scope() + |> Scope.new(id, range, module) + + push_scope(state, scope) + end + + def push_scope_for(%__MODULE__{} = state, quoted, %Range{} = range, module) do + module = module || current_module(state) + + id = Analysis.scope_id(quoted) + push_scope(state, id, range, module) + end + + def push_scope_for(%__MODULE__{} = state, quoted, module) do + range = get_range(quoted, state.document) + push_scope_for(state, quoted, range, module) + end + + def maybe_push_scope_for(%__MODULE__{} = state, quoted) do + case get_range(quoted, state.document) do + %Range{} = range -> + push_scope_for(state, quoted, range, nil) + + nil -> + state + end + end + + def pop_scope(%__MODULE__{scopes: [scope | rest]} = state) do + %__MODULE__{state | scopes: rest, visited: Map.put(state.visited, scope.id, scope)} + end + + def push_alias(%__MODULE__{} = state, %Alias{} = alias) do + update_current_scope(state, fn %Scope{} = scope -> + [prefix | rest] = alias.module + + alias = + case Scope.fetch_alias_with_prefix(scope, prefix) do + {:ok, %Alias{} = existing_alias} -> + %Alias{alias | module: existing_alias.module ++ rest} + + :error -> + alias + end + + Map.update!(scope, :aliases, &[alias | &1]) + end) + end + + def push_import(%__MODULE__{} = state, %Import{} = import) do + update_current_scope(state, fn %Scope{} = scope -> + Map.update!(scope, :imports, &[import | &1]) + end) + end + + def push_require(%__MODULE__{} = state, %Require{} = require) do + update_current_scope(state, fn %Scope{} = scope -> + Map.update!(scope, :requires, &[require | &1]) + end) + end + + def push_use(%__MODULE__{} = state, %Use{} = use) do + update_current_scope(state, fn %Scope{} = scope -> + Map.update!(scope, :uses, &[use | &1]) + end) + end + + defp update_current_scope(%__MODULE__{} = state, fun) do + update_in(state, [Access.key(:scopes), Access.at!(0)], fn %Scope{} = scope -> + fun.(scope) + end) + end + + # if there is no code after a stab operator, then the end position + # it gives us can be in the middle of the line, as it's derived from + # the start of some entity on the last line. So we increment the line + # by one, and that should be the end of the stab block + defp get_range({:->, _, _} = quoted, %Document{} = document) do + start_pos = get_start_position(quoted) + + case Sourceror.get_end_position(quoted, line: -1, column: -1) do + [line: -1, column: -1] -> + nil + + [line: line, column: 1] -> + Range.new( + Position.new(document, start_pos[:line], start_pos[:column]), + Position.new(document, line + 1, 1) + ) + + [line: line, column: _] -> + Range.new( + Position.new(document, start_pos[:line], start_pos[:column]), + Position.new(document, line + 1, 1) + ) + end + end + + defp get_range(quoted, %Document{} = document) do + start_pos = get_start_position(quoted) + + case Sourceror.get_end_position(quoted, line: -1, column: -1) do + [line: -1, column: -1] -> + nil + + [line: end_line, column: end_column] -> + Range.new( + Position.new(document, start_pos[:line], start_pos[:column]), + Position.new(document, end_line, end_column) + ) + end + end + + defp global_range(%Document{} = document) do + num_lines = Document.size(document) + + Range.new( + Position.new(document, 1, 1), + Position.new(document, num_lines + 1, 1) + ) + end + + defp get_start_position({_, metadata, _} = ast) do + case Keyword.fetch(metadata, :do) do + {:ok, [line: line, column: column]} -> + # add 2 to position us after the do keyword + [line: line, column: column + 2] + + _ -> + Sourceror.get_start_position(ast) + end + end + + defp get_start_position({block_meta, _rest}) do + case Sourceror.get_start_position(block_meta) do + [line: line, column: column] -> + [line: line, column: column + 2] + + other -> + other + end + end +end diff --git a/forge/lib/forge/ast/analysis/use.ex b/forge/lib/forge/ast/analysis/use.ex new file mode 100644 index 00000000..7891e0f1 --- /dev/null +++ b/forge/lib/forge/ast/analysis/use.ex @@ -0,0 +1,10 @@ +defmodule Forge.Ast.Analysis.Use do + alias Forge.Ast + alias Forge.Document + defstruct [:module, :range, :opts] + + def new(%Document{} = document, ast, module, opts) do + range = Ast.Range.get(ast, document) + %__MODULE__{range: range, module: module, opts: opts} + end +end diff --git a/forge/lib/forge/ast/detection.ex b/forge/lib/forge/ast/detection.ex new file mode 100644 index 00000000..9b64fee3 --- /dev/null +++ b/forge/lib/forge/ast/detection.ex @@ -0,0 +1,109 @@ +defmodule Forge.Ast.Detection do + @moduledoc """ + A behavior for context detection + + A context recognizer can recognize the type of code at a current position. + It is useful for identifying the "part of speech" of a position. + + Note: a given context might be detected by more than one module. + """ + + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Document.Position + alias Forge.Document.Range + + @doc """ + Returns true if the given position is detected by the current module + """ + @callback detected?(Analysis.t(), Position.t()) :: boolean() + + defmacro __using__(_) do + quote do + @behaviour unquote(__MODULE__) + import unquote(__MODULE__) + end + end + + def ancestor_is_def?(%Analysis{} = analysis, %Position{} = position) do + analysis + |> Ast.cursor_path(position) + |> Enum.any?(fn + {:def, _, _} -> + true + + {:defp, _, _} -> + true + + _ -> + false + end) + end + + @type_keys [:type, :typep, :opaque] + def ancestor_is_type?(%Analysis{} = analysis, %Position{} = position) do + ancestor_is_attribute?(analysis, position, @type_keys) + end + + def ancestor_is_spec?(%Analysis{} = analysis, %Position{} = position) do + ancestor_is_attribute?(analysis, position, :spec) + end + + def ancestor_is_attribute?(%Analysis{} = analysis, %Position{} = position, attr_name \\ nil) do + analysis + |> Ast.cursor_path(position) + |> Enum.any?(fn + {:@, metadata, [{found_name, _, _}]} -> + # single line attribute + attribute_names_match?(attr_name, found_name) and cursor_in_range?(position, metadata) + + {:__block__, _, [{:@, metadata, [{found_name, _, _}]}, _]} -> + # multi-line attribute + attribute_names_match?(attr_name, found_name) and cursor_in_range?(position, metadata) + + _ -> + false + end) + end + + def fetch_range(ast) do + fetch_range(ast, 0, 0) + end + + def fetch_range(ast, start_offset, end_offset) do + case Sourceror.get_range(ast) do + %{start: [line: start_line, column: start_col], end: [line: end_line, column: end_col]} -> + range = + Range.new( + %Position{line: start_line, character: start_col + start_offset}, + %Position{line: end_line, character: end_col + end_offset} + ) + + {:ok, range} + + nil -> + :error + end + end + + defp cursor_in_range?(position, metadata) do + expression_end_line = get_in(metadata, [:end_of_expression, :line]) + expression_end_column = get_in(metadata, [:end_of_expression, :column]) + cursor_line = position.line + cursor_column = position.character + + if cursor_line == expression_end_line do + expression_end_column > cursor_column + else + cursor_line < expression_end_line + end + end + + defp attribute_names_match?(expected_names, actual_name) + when is_list(expected_names), + do: actual_name in expected_names + + defp attribute_names_match?(nil, _), do: true + defp attribute_names_match?(same, same), do: true + defp attribute_names_match?(_, _), do: false +end diff --git a/forge/lib/forge/ast/detection/alias.ex b/forge/lib/forge/ast/detection/alias.ex new file mode 100644 index 00000000..0ba863a0 --- /dev/null +++ b/forge/lib/forge/ast/detection/alias.ex @@ -0,0 +1,64 @@ +defmodule Forge.Ast.Detection.Alias do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Tokens + alias Forge.Document.Position + + use Detection + + @doc """ + Recognizes an alias at the current position + + Aliases are complicated, especially if we're trying to find out if we're in + them from the current cursor position moving backwards. + I'll try to describe the state machine below. + First off, if we're outside of a } on the current line, we cannot be in an alias, so that + halts with false. + Similarly an alias on the current line is also simple, we just backtrack until we see the alias identifier. + However, if we're on the current line, and see an EOL, we set that as our accumulator, then we get + to the previous line, we see if it ends in a comma. If not, we can't be in an alias. If it does, we keep + backtracking until we hit the alias keyword. + So basically, if we hit an EOL, and the previous token isn't an open curly or a comma, we stop, otherwise + we backtrack until we hit the alias keyword + """ + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + result = + analysis.document + |> Tokens.prefix_stream(position) + |> Stream.with_index() + |> Enum.reduce_while(false, fn + {{:curly, :"{", _}, _index}, :eol -> + {:cont, false} + + {{:comma, _, _}, _index}, :eol -> + {:cont, false} + + {{:eol, _, _}, _index}, _acc -> + {:cont, :eol} + + {{_, _, _}, _}, :eol -> + {:halt, false} + + {{:curly, :"}", _}, _index}, _ -> + {:halt, false} + + {{:identifier, ~c"alias", _}, 0}, _ -> + # there is nothing after the alias directive, so we're not + # inside the context *yet* + + {:halt, false} + + {{:identifier, ~c"alias", _}, _index}, _ -> + {:halt, true} + + _, _ -> + {:cont, false} + end) + + case result do + b when is_boolean(b) -> b + :eol -> false + end + end +end diff --git a/forge/lib/forge/ast/detection/bitstring.ex b/forge/lib/forge/ast/detection/bitstring.ex new file mode 100644 index 00000000..13f0d3b2 --- /dev/null +++ b/forge/lib/forge/ast/detection/bitstring.ex @@ -0,0 +1,26 @@ +defmodule Forge.Ast.Detection.Bitstring do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Tokens + alias Forge.Document + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + document = analysis.document + Document.fragment(document, Position.new(document, position.line, 1), position) + + document + |> Tokens.prefix_stream(position) + |> Enum.reduce_while( + false, + fn + {:operator, :">>", _}, _ -> {:halt, false} + {:operator, :"<<", _}, _ -> {:halt, true} + _, _ -> {:cont, false} + end + ) + end +end diff --git a/forge/lib/forge/ast/detection/comment.ex b/forge/lib/forge/ast/detection/comment.ex new file mode 100644 index 00000000..f3dd652c --- /dev/null +++ b/forge/lib/forge/ast/detection/comment.ex @@ -0,0 +1,8 @@ +defmodule Forge.Ast.Detection.Comment do + alias Forge.Ast.Analysis + alias Forge.Document.Position + + def detected?(%Analysis{} = analysis, %Position{} = position) do + Analysis.commented?(analysis, position) + end +end diff --git a/forge/lib/forge/ast/detection/directive.ex b/forge/lib/forge/ast/detection/directive.ex new file mode 100644 index 00000000..e0243d8e --- /dev/null +++ b/forge/lib/forge/ast/detection/directive.ex @@ -0,0 +1,21 @@ +defmodule Forge.Ast.Detection.Directive do + alias Forge.Ast.Analysis + alias Forge.Ast.Tokens + alias Forge.Document.Position + + def detected?(%Analysis{} = analysis, %Position{} = position, directive_type) do + analysis.document + |> Tokens.prefix_stream(position) + |> Enum.to_list() + |> Enum.reduce_while(false, fn + {:identifier, ^directive_type, _}, _ -> + {:halt, true} + + {:eol, _, _}, _ -> + {:halt, false} + + _, _ -> + {:cont, false} + end) + end +end diff --git a/forge/lib/forge/ast/detection/function_capture.ex b/forge/lib/forge/ast/detection/function_capture.ex new file mode 100644 index 00000000..85d5d726 --- /dev/null +++ b/forge/lib/forge/ast/detection/function_capture.ex @@ -0,0 +1,32 @@ +defmodule Forge.Ast.Detection.FunctionCapture do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Tokens + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + analysis.document + |> Tokens.prefix_stream(position) + |> Enum.reduce_while(false, fn + {:paren, :")", _}, _ -> + {:halt, false} + + {:operator, :&, _}, _ -> + {:halt, true} + + {:int, _, _} = maybe_arity, _ -> + {:cont, maybe_arity} + + {:operator, :/, _}, {:int, _, _} -> + # if we encounter a trailing / in the prefix, the + # function capture is complete, and we're not inside it + {:halt, false} + + _, _ -> + {:cont, false} + end) + end +end diff --git a/forge/lib/forge/ast/detection/import.ex b/forge/lib/forge/ast/detection/import.ex new file mode 100644 index 00000000..9684e75f --- /dev/null +++ b/forge/lib/forge/ast/detection/import.ex @@ -0,0 +1,13 @@ +defmodule Forge.Ast.Detection.Import do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Detection.Directive + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + Directive.detected?(analysis, position, ~c"import") + end +end diff --git a/forge/lib/forge/ast/detection/module_attribute.ex b/forge/lib/forge/ast/detection/module_attribute.ex new file mode 100644 index 00000000..38e128ce --- /dev/null +++ b/forge/lib/forge/ast/detection/module_attribute.ex @@ -0,0 +1,16 @@ +defmodule Forge.Ast.Detection.ModuleAttribute do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + ancestor_is_attribute?(analysis, position) + end + + def detected?(%Analysis{} = analysis, %Position{} = position, name) do + ancestor_is_attribute?(analysis, position, name) + end +end diff --git a/forge/lib/forge/ast/detection/pipe.ex b/forge/lib/forge/ast/detection/pipe.ex new file mode 100644 index 00000000..8ca61f93 --- /dev/null +++ b/forge/lib/forge/ast/detection/pipe.ex @@ -0,0 +1,34 @@ +defmodule Forge.Ast.Detection.Pipe do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Tokens + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + analysis.document + |> Tokens.prefix_stream(position) + |> Enum.to_list() + |> Enum.reduce_while(false, fn + {:identifier, _, _}, _ -> + {:cont, false} + + {:operator, :., _}, _ -> + {:cont, false} + + {:alias, _, _}, _ -> + {:cont, false} + + {:arrow_op, nil, _}, _ -> + {:halt, true} + + {:atom, _, _}, _ -> + {:cont, false} + + _, _acc -> + {:halt, false} + end) + end +end diff --git a/forge/lib/forge/ast/detection/require.ex b/forge/lib/forge/ast/detection/require.ex new file mode 100644 index 00000000..f989f1ea --- /dev/null +++ b/forge/lib/forge/ast/detection/require.ex @@ -0,0 +1,13 @@ +defmodule Forge.Ast.Detection.Require do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Detection.Directive + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + Directive.detected?(analysis, position, ~c"require") + end +end diff --git a/forge/lib/forge/ast/detection/spec.ex b/forge/lib/forge/ast/detection/spec.ex new file mode 100644 index 00000000..7503a79a --- /dev/null +++ b/forge/lib/forge/ast/detection/spec.ex @@ -0,0 +1,12 @@ +defmodule Forge.Ast.Detection.Spec do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + ancestor_is_spec?(analysis, position) + end +end diff --git a/forge/lib/forge/ast/detection/string.ex b/forge/lib/forge/ast/detection/string.ex new file mode 100644 index 00000000..adfeda6d --- /dev/null +++ b/forge/lib/forge/ast/detection/string.ex @@ -0,0 +1,109 @@ +defmodule Forge.Ast.Detection.String do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Document.Position + alias Forge.Document.Position + alias Forge.Document.Range + + use Detection + + @string_sigils [ + :sigil_s, + :sigil_S + ] + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + case Ast.path_at(analysis, position) do + {:ok, path} -> + detect_string(path, position) + + _ -> + false + end + end + + defp detect_string(paths, %Position{} = position) do + {_, detected?} = + Macro.postwalk(paths, false, fn + ast, false -> + detected? = do_detect(ast, position) + {ast, detected?} + + ast, true -> + {ast, true} + end) + + detected? + end + + # a string literal + defp do_detect({:__block__, _, [literal]} = ast, %Position{} = position) + when is_binary(literal) do + case fetch_range(ast, 0, -1) do + {:ok, range} -> Range.contains?(range, position) + :error -> false + end + end + + # a possible string with interpolation + defp do_detect({:<<>>, meta, _} = ast, %Position{} = position) do + # this might also be a binary match / construction + Keyword.has_key?(meta, :delimiter) and detect_interpolation(ast, position) + end + + # String sigils + defp do_detect({sigil, _, _} = ast, %Position{} = position) + when sigil in @string_sigils do + case fetch_range(ast, 0, 0) do + {:ok, range} -> Range.contains?(range, position) + _ -> false + end + end + + defp do_detect(_, _), + do: false + + # a string with interpolation + defp detect_interpolation( + {:<<>>, meta, interpolations} = ast, + %Position{} = position + ) do + delimiter_length = + meta + |> Keyword.get(:delimiter, "\"") + |> String.length() + + with {:ok, string_range} <- fetch_range(ast, delimiter_length, -1), + {:ok, interpolation_ranges} <- collect_interpolation_ranges(interpolations) do + Range.contains?(string_range, position) and + not Enum.any?(interpolation_ranges, &Range.contains?(&1, position)) + else + _ -> + false + end + end + + defp collect_interpolation_ranges(interpolations) do + {_, result} = + Macro.prewalk(interpolations, {:ok, []}, fn + ast, :error -> + {ast, :error} + + {:"::", _, _} = interpolation, {:ok, acc} -> + case fetch_range(interpolation, 1, -1) do + {:ok, range} -> + {interpolation, {:ok, [range | acc]}} + + :error -> + {interpolation, :error} + end + + ast, acc -> + {ast, acc} + end) + + result + end +end diff --git a/forge/lib/forge/ast/detection/struct_field_key.ex b/forge/lib/forge/ast/detection/struct_field_key.ex new file mode 100644 index 00000000..4d3d2635 --- /dev/null +++ b/forge/lib/forge/ast/detection/struct_field_key.ex @@ -0,0 +1,21 @@ +defmodule Forge.Ast.Detection.StructFieldKey do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + cursor_path = Ast.cursor_path(analysis, position) + + match?( + # in the key position, the cursor will always be followed by the + # map node because, in any other case, there will minimally be a + # 2-element key-value tuple containing the cursor + [{:__cursor__, _, _}, {:%{}, _, _}, {:%, _, _} | _], + cursor_path + ) + end +end diff --git a/forge/lib/forge/ast/detection/struct_field_value.ex b/forge/lib/forge/ast/detection/struct_field_value.ex new file mode 100644 index 00000000..3584190e --- /dev/null +++ b/forge/lib/forge/ast/detection/struct_field_value.ex @@ -0,0 +1,11 @@ +defmodule Forge.Ast.Detection.StructFieldValue do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection.StructFieldKey + alias Forge.Ast.Detection.StructFields + alias Forge.Document.Position + + def detected?(%Analysis{} = analysis, %Position{} = position) do + StructFields.detected?(analysis, position) and + not StructFieldKey.detected?(analysis, position) + end +end diff --git a/forge/lib/forge/ast/detection/struct_fields.ex b/forge/lib/forge/ast/detection/struct_fields.ex new file mode 100644 index 00000000..a1bfb8b8 --- /dev/null +++ b/forge/lib/forge/ast/detection/struct_fields.ex @@ -0,0 +1,15 @@ +defmodule Forge.Ast.Detection.StructFields do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + analysis.document + |> Ast.cursor_path(position) + |> Enum.any?(&match?({:%, _, _}, &1)) + end +end diff --git a/forge/lib/forge/ast/detection/struct_reference.ex b/forge/lib/forge/ast/detection/struct_reference.ex new file mode 100644 index 00000000..2deec733 --- /dev/null +++ b/forge/lib/forge/ast/detection/struct_reference.ex @@ -0,0 +1,43 @@ +defmodule Forge.Ast.Detection.StructReference do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Tokens + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + case Ast.cursor_context(analysis, position) do + {:ok, {:struct, []}} -> + false + + {:ok, {:struct, _}} -> + true + + {:ok, {:local_or_var, [?_ | _rest] = possible_module_struct}} -> + # a reference to `%__MODULE`, often in a function head, as in + # def foo(%__) + + starts_with_percent? = + analysis.document + |> Tokens.prefix_stream(position) + |> Enum.take(2) + |> Enum.any?(fn + {:percent, :%, _} -> true + _ -> false + end) + + starts_with_percent? and possible_dunder_module(possible_module_struct) and + (ancestor_is_def?(analysis, position) or ancestor_is_type?(analysis, position)) + + _ -> + false + end + end + + def possible_dunder_module(charlist) do + String.starts_with?("__MODULE__", to_string(charlist)) + end +end diff --git a/forge/lib/forge/ast/detection/type.ex b/forge/lib/forge/ast/detection/type.ex new file mode 100644 index 00000000..43ee1cbf --- /dev/null +++ b/forge/lib/forge/ast/detection/type.ex @@ -0,0 +1,12 @@ +defmodule Forge.Ast.Detection.Type do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + ancestor_is_type?(analysis, position) + end +end diff --git a/forge/lib/forge/ast/detection/use.ex b/forge/lib/forge/ast/detection/use.ex new file mode 100644 index 00000000..0057b112 --- /dev/null +++ b/forge/lib/forge/ast/detection/use.ex @@ -0,0 +1,13 @@ +defmodule Forge.Ast.Detection.Use do + alias Forge.Ast.Analysis + alias Forge.Ast.Detection + alias Forge.Ast.Detection.Directive + alias Forge.Document.Position + + use Detection + + @impl Detection + def detected?(%Analysis{} = analysis, %Position{} = position) do + Directive.detected?(analysis, position, ~c"use") + end +end diff --git a/forge/lib/forge/ast/env.ex b/forge/lib/forge/ast/env.ex new file mode 100644 index 00000000..af9db84b --- /dev/null +++ b/forge/lib/forge/ast/env.ex @@ -0,0 +1,238 @@ +defmodule Forge.Ast.Env do + @moduledoc """ + Representation of the environment at a given position in a document. + """ + + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Analysis.Scope + alias Forge.Ast.Detection + alias Forge.Ast.Tokens + alias Forge.Document + alias Forge.Document.Position + alias Forge.Project + + defstruct [ + :project, + :analysis, + :document, + :line, + :prefix, + :suffix, + :position, + :position_module, + :zero_based_character + ] + + @type t :: %__MODULE__{ + project: Project.t(), + analysis: Analysis.t(), + document: Document.t(), + line: String.t(), + prefix: String.t(), + suffix: String.t(), + position: Position.t(), + position_module: String.t(), + zero_based_character: non_neg_integer() + } + + @type token_value :: String.t() | charlist() | atom() + @type lexer_token :: {atom, token_value, {line :: pos_integer(), col :: pos_integer()}} + @type token_count :: pos_integer | :all + + @type context_type :: + :pipe + | :alias + | :struct_reference + | :struct_fields + | :struct_field_key + | :struct_field_value + | :function_capture + | :bitstring + | :comment + | :string + | :use + | :impl + | :spec + | :type + + def new(%Project{} = project, %Analysis{} = analysis, %Position{} = cursor_position) do + zero_based_character = cursor_position.character - 1 + + case Document.fetch_text_at(analysis.document, cursor_position.line) do + {:ok, line} -> + prefix = String.slice(line, 0, zero_based_character) + suffix = String.slice(line, zero_based_character..-1//1) + + analysis = Ast.reanalyze_to(analysis, cursor_position) + + cursor_module = + case Analysis.scopes_at(analysis, cursor_position) do + [%Scope{module: local_module} | _] -> + Enum.join(local_module, ".") + + [] -> + "" + end + + env = %__MODULE__{ + analysis: analysis, + document: analysis.document, + line: line, + position: cursor_position, + position_module: cursor_module, + prefix: prefix, + project: project, + suffix: suffix, + zero_based_character: zero_based_character + } + + {:ok, env} + + _ -> + {:error, {:out_of_bounds, cursor_position}} + end + end + + @spec prefix_tokens(t, token_count) :: [lexer_token] + def prefix_tokens(%__MODULE__{} = env, count \\ :all) do + stream = Tokens.prefix_stream(env.document, env.position) + + case count do + :all -> + stream + + count when is_integer(count) -> + Enum.take(stream, count) + end + end + + @spec in_context?(t, context_type) :: boolean() + # credo:disable-for-next-line Credo.Check.Refactor.CyclomaticComplexity + def in_context?(%__MODULE__{} = env, context_type) do + analysis = env.analysis + position = env.position + + case context_type do + :alias -> + Detection.Alias.detected?(analysis, position) + + :behaviour -> + Detection.ModuleAttribute.detected?(analysis, position, :behaviour) + + :bitstring -> + Detection.Bitstring.detected?(analysis, position) + + :callback -> + Detection.ModuleAttribute.detected?(analysis, position, :callback) + + :comment -> + Detection.Comment.detected?(analysis, position) + + :doc -> + Detection.ModuleAttribute.detected?(analysis, position, :doc) + + :function_capture -> + Detection.FunctionCapture.detected?(analysis, position) + + :impl -> + Detection.ModuleAttribute.detected?(analysis, position, :impl) + + :import -> + Detection.Import.detected?(analysis, position) + + :module_attribute -> + Detection.ModuleAttribute.detected?(analysis, position) + + {:module_attribute, name} -> + Detection.ModuleAttribute.detected?(analysis, position, name) + + :macrocallback -> + Detection.ModuleAttribute.detected?(analysis, position, :macrocallback) + + :moduledoc -> + Detection.ModuleAttribute.detected?(analysis, position, :moduledoc) + + :pipe -> + Detection.Pipe.detected?(analysis, position) + + :require -> + Detection.Require.detected?(analysis, position) + + :spec -> + Detection.Spec.detected?(analysis, position) + + :string -> + Detection.String.detected?(analysis, position) + + :struct_fields -> + Detection.StructFields.detected?(analysis, position) + + :struct_field_key -> + Detection.StructFieldKey.detected?(analysis, position) + + :struct_field_value -> + Detection.StructFieldValue.detected?(analysis, position) + + :struct_reference -> + Detection.StructReference.detected?(analysis, position) + + :type -> + Detection.Type.detected?(analysis, position) + + :use -> + Detection.Use.detected?(analysis, position) + end + end + + @spec empty?(String.t()) :: boolean() + def empty?("") do + true + end + + def empty?(string) when is_binary(string) do + String.trim(string) == "" + end + + @doc """ + Returns the position of the next non-whitespace token on a line after `env.position`. + """ + @spec next_significant_position(t) :: {:ok, Position.t()} | :error + def next_significant_position(%__MODULE__{} = env) do + find_significant_position(env.document, env.position.line + 1, 1) + end + + @doc """ + Returns the position of the next non-whitespace token on a line before `env.position`. + """ + @spec prev_significant_position(t) :: {:ok, Position.t()} | :error + def prev_significant_position(%__MODULE__{} = env) do + find_significant_position(env.document, env.position.line - 1, -1) + end + + defp find_significant_position(%Document{} = document, line, inc_by) do + case Document.fetch_text_at(document, line) do + {:ok, text} -> + case fetch_leading_whitespace_count(text) do + {:ok, count} -> + {:ok, Position.new(document, line, count + 1)} + + :error -> + find_significant_position(document, line + inc_by, inc_by) + end + + :error -> + :error + end + end + + defp fetch_leading_whitespace_count(string, count \\ 0) + + defp fetch_leading_whitespace_count(<<" ", rest::binary>>, count) do + fetch_leading_whitespace_count(rest, count + 1) + end + + defp fetch_leading_whitespace_count(<<>>, _count), do: :error + defp fetch_leading_whitespace_count(<<"\n" <> _::binary>>, _count), do: :error + defp fetch_leading_whitespace_count(<<_non_whitespace::binary>>, count), do: {:ok, count} +end diff --git a/forge/lib/forge/ast/module.ex b/forge/lib/forge/ast/module.ex new file mode 100644 index 00000000..0a4ad54d --- /dev/null +++ b/forge/lib/forge/ast/module.ex @@ -0,0 +1,99 @@ +defmodule Forge.Ast.Module do + @moduledoc """ + Module utilities + """ + + @doc """ + Formats a module name as a string. + """ + @spec name(module() | Macro.t() | String.t()) :: String.t() + def name([{:__MODULE__, _, _} | rest]) do + [__MODULE__ | rest] + |> Module.concat() + |> name() + end + + def name(module_name) when is_list(module_name) do + module_name + |> Module.concat() + |> name() + end + + def name(module_name) when is_binary(module_name) do + module_name + end + + def name(module_name) when is_atom(module_name) do + module_name + |> inspect() + |> name() + end + + @doc """ + local module name is the last part of a module name + + ## Examples: + iex> local_name('Forge.Ast.Module') + "Module" + """ + def local_name(entity) when is_list(entity) do + entity + |> to_string() + |> local_name() + end + + def local_name(entity) when is_binary(entity) do + entity + |> String.split(".") + |> List.last() + end + + @doc """ + Splits a module into is parts, but handles erlang modules + + Module.split will explode violently when called on an erlang module. This + implementation will tell you which kind of module it has split, and return the + pieces. You can also use the options to determine if the pieces are returned as + strings or atoms + + Options: + `as` :atoms or :binaries. Default is :binary. Determines what type the elements + of the returned list are. + + Returns: + A tuple where the first element is either `:elixir` or `:erlang`, which tells you + the kind of module that has been split. The second element is a list of the + module's components. Note: Erlang modules will only ever have a single component. + """ + @type split_opt :: {:as, :binaries | :atoms} + @type split_opts :: [split_opt()] + @type split_return :: {:elixir | :erlang, [String.t()] | [atom()]} + + @spec safe_split(module()) :: split_return() + @spec safe_split(module(), split_opts()) :: split_return() + def safe_split(module, opts \\ []) + + def safe_split(module, opts) when is_atom(module) do + string_name = Atom.to_string(module) + + {type, split_module} = + case String.split(string_name, ".") do + ["Elixir" | rest] -> + {:elixir, rest} + + [_erlang_module] = module -> + {:erlang, module} + end + + split_module = + case Keyword.get(opts, :as, :binaries) do + :binaries -> + split_module + + :atoms -> + Enum.map(split_module, &String.to_atom/1) + end + + {type, split_module} + end +end diff --git a/forge/lib/forge/ast/range.ex b/forge/lib/forge/ast/range.ex new file mode 100644 index 00000000..e5190d4f --- /dev/null +++ b/forge/lib/forge/ast/range.ex @@ -0,0 +1,48 @@ +defmodule Forge.Ast.Range do + @moduledoc """ + Utilities for extracting ranges from ast nodes + """ + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + + @spec fetch(Macro.t(), Document.t()) :: {:ok, Range.t()} | :error + def fetch(ast, %Document{} = document) do + case Sourceror.get_range(ast) do + %{start: start_pos, end: end_pos} -> + [line: start_line, column: start_column] = start_pos + [line: end_line, column: end_column] = end_pos + + range = + Range.new( + Position.new(document, start_line, start_column), + Position.new(document, end_line, end_column) + ) + + {:ok, range} + + _ -> + :error + end + end + + @spec fetch!(Macro.t(), Document.t()) :: Range.t() + def fetch!(ast, %Document{} = document) do + case fetch(ast, document) do + {:ok, range} -> + range + + :error -> + raise ArgumentError, + message: "Could not get a range for #{inspect(ast)} in #{document.path}" + end + end + + @spec get(Macro.t(), Document.t()) :: Range.t() | nil + def get(ast, %Document{} = document) do + case fetch(ast, document) do + {:ok, range} -> range + :error -> nil + end + end +end diff --git a/forge/lib/forge/ast/tokens.ex b/forge/lib/forge/ast/tokens.ex new file mode 100644 index 00000000..125314f5 --- /dev/null +++ b/forge/lib/forge/ast/tokens.ex @@ -0,0 +1,169 @@ +defmodule Forge.Ast.Tokens do + alias Forge.Document + alias Forge.Document.Position + + @doc """ + Returns a stream of tokens starting at the given position and working backwards through + the document. + """ + def prefix_stream(%Document{} = document, %Position{} = position) do + init_function = fn -> + {~c"", position.line} + end + + next_function = fn + {_, 0} -> + {:halt, []} + + {current_context, line_number} -> + case find_and_tokenize(document, position, line_number, current_context) do + {:ok, tokens, new_context} -> + prev_line_number = line_number - 1 + + tokens = + if prev_line_number > 0 do + tokens ++ [:eol] + else + tokens + end + + {tokens, {new_context, prev_line_number}} + + :stop -> + {:halt, []} + end + end + + finalize_function = fn _ -> :ok end + + init_function + |> Stream.resource(next_function, finalize_function) + |> Stream.map(&normalize_token/1) + end + + defp find_and_tokenize( + %Document{} = document, + %Position{line: line_number} = position, + line_number, + context + ) do + document + |> prefix(position) + |> tokenize(line_number, context) + end + + defp find_and_tokenize(%Document{} = document, %Position{}, line_number, context) do + case Document.fetch_text_at(document, line_number) do + {:ok, line_text} -> + tokenize(line_text, line_number, context) + + :error -> + :stop + end + end + + defp tokenize(line_text, line_number, context) do + line_charlist = String.to_charlist(line_text) + current_context = line_charlist ++ context + + case :future_elixir_tokenizer.tokenize(current_context, line_number, 1, []) do + {:ok, _, _, _, tokens, _} -> + {:ok, tokens, ~c""} + + {:error, {_, ~c"unexpected token: ", _}, _, _, _} -> + {:ok, [], ~c"\n" ++ current_context} + + {:error, _, _, _, tokens} -> + {:ok, tokens, ~c""} + end + end + + defp prefix(%Document{} = document, %Position{} = position) do + zero_based_character = position.character - 1 + {:ok, line_text} = Document.fetch_text_at(document, position.line) + String.slice(line_text, 0, zero_based_character) + end + + # credo:disable-for-next-line Credo.Check.Refactor.CyclomaticComplexity + defp normalize_token(token) do + case token do + :eol -> + {:eol, ~c"\n", []} + + {:bin_string, context, [string_value]} -> + {:string, string_value, to_position(context)} + + {:bin_string, context, interpolated} -> + {:interpolated_string, interpolation_ranges(interpolated), to_position(context)} + + {:capture_op, context, value} -> + {:operator, value, to_position(context)} + + {:dual_op, context, value} -> + {:operator, value, to_position(context)} + + {:type_op, context, _value} -> + {:operator, :"::", to_position(context)} + + {:mult_op, context, operator} -> + {:operator, operator, to_position(context)} + + {:in_op, context, _} -> + {:operator, :in, to_position(context)} + + {:operator, context, value} -> + {:operator, value, to_position(context)} + + {:sigil, {line, column, _}, sigil_char, _sigil_context, _, _opts, delim} -> + # NOTE: should we need to return context too? + {:sigil, [sigil_char], {line, column}, delim} + + {type, {line, column, token_value}, _} -> + {normalize_type(type), token_value, {line, column}} + + {type, context, value} when is_atom(value) -> + {normalize_type(type), value, to_position(context)} + + {operator, context} -> + {map_operator(operator), operator, to_position(context)} + end + end + + defp to_position({line, column, _}) do + {line, column} + end + + defp map_operator(:"("), do: :paren + defp map_operator(:")"), do: :paren + defp map_operator(:"{"), do: :curly + defp map_operator(:"}"), do: :curly + defp map_operator(:","), do: :comma + defp map_operator(:%{}), do: :map_new + defp map_operator(:%), do: :percent + defp map_operator(_), do: :operator + + defp normalize_type(:flt), do: :float + defp normalize_type(:bin_string), do: :string + defp normalize_type(type), do: type + + defp interpolation_ranges(interpolations) do + {_, ranges} = + Enum.reduce(interpolations, {{1, 1}, []}, fn + literal, {{line, column}, acc} when is_binary(literal) -> + end_pos = {line, column + String.length(literal)} + range = {{line, column}, end_pos} + {end_pos, [{:literal, literal, range} | acc]} + + {_, {end_line, end_column, _}, interp}, {_, acc} -> + start_pos = get_start_pos(interp) + range = {start_pos, {end_line, end_column}} + {{end_line, end_column}, [{:interpolation, interp, range} | acc]} + end) + + Enum.reverse(ranges) + end + + defp get_start_pos([{_, {start_line, start_column, _}, _} | _]) do + {start_line, start_column} + end +end diff --git a/forge/lib/forge/code_unit.ex b/forge/lib/forge/code_unit.ex new file mode 100644 index 00000000..ce2d67dc --- /dev/null +++ b/forge/lib/forge/code_unit.ex @@ -0,0 +1,125 @@ +defmodule Forge.CodeUnit do + @moduledoc """ + Code unit and offset conversions. + + LSP positions are encoded as UTF-16 code unit offsets from the beginning of a line, + while positions in Elixir are UTF-8 character positions (graphemes). This module + deals with converting between the two. + """ + + @type utf8_character_position :: non_neg_integer() + @type utf8_code_unit_offset :: non_neg_integer() + @type utf16_code_unit_offset :: non_neg_integer() + + @type error :: {:error, :misaligned} | {:error, :out_of_bounds} + + @doc """ + Converts a 0-based UTF-8 character position to a UTF-16 code unit offset. + """ + @spec utf8_position_to_utf16_offset(String.t(), utf8_character_position()) :: + utf16_code_unit_offset() + def utf8_position_to_utf16_offset(binary, character_position) do + binary + |> String.slice(0, character_position) + |> :unicode.characters_to_binary(:utf8, :utf16) + |> byte_size() + |> div(2) + end + + @doc """ + Converts a 0-based UTF-16 code unit offset to a UTF-8 code unit offset. + """ + @spec utf16_offset_to_utf8_offset(String.t(), utf16_code_unit_offset()) :: + {:ok, utf8_code_unit_offset()} | error + def utf16_offset_to_utf8_offset(binary, utf16_unit) do + do_to_utf8(binary, utf16_unit, 1) + end + + @doc """ + Counts the number of utf16 code units in the binary + """ + @spec count(:utf16 | :utf8, binary()) :: non_neg_integer + def count(:utf16, binary) do + do_count_utf16(binary, 0) + end + + def count(:utf8, binary) do + do_count_utf8(binary, 0) + end + + # Private + + # UTF-16 + + defp do_count_utf16(<<>>, count) do + count + end + + defp do_count_utf16(<>, count) when c < 128 do + do_count_utf16(rest, count + 1) + end + + defp do_count_utf16(<>, count) do + do_count_utf16(rest, count + code_unit_size(c, :utf16)) + end + + defp do_count_utf8(<<>>, count) do + count + end + + defp do_count_utf8(<>, count) when c < 128 do + do_count_utf8(rest, count + 1) + end + + defp do_count_utf8(<>, count) do + increment = code_unit_size(c, :utf8) + do_count_utf8(rest, count + increment) + end + + # UTF-8 + + defp do_to_utf8(_, 0, utf8_unit) do + {:ok, utf8_unit} + end + + defp do_to_utf8(_, utf_16_units, _) when utf_16_units < 0 do + {:error, :misaligned} + end + + defp do_to_utf8(<<>>, _remaining, _utf8_unit) do + {:error, :out_of_bounds} + end + + defp do_to_utf8(<>, utf16_unit, utf8_unit) when c < 128 do + do_to_utf8(rest, utf16_unit - 1, utf8_unit + 1) + end + + defp do_to_utf8(<>, utf16_unit, utf8_unit) do + utf8_code_units = code_unit_size(c, :utf8) + utf16_code_units = code_unit_size(c, :utf16) + + do_to_utf8(rest, utf16_unit - utf16_code_units, utf8_unit + utf8_code_units) + end + + @unicode_range 0..0x10_FFFF + + defp code_unit_size(c, :utf16) when c in @unicode_range do + case c do + c when c in 0x0000..0xFFFF -> + 1 + + _ -> + 2 + end + end + + defp code_unit_size(c, :utf8) when c in @unicode_range do + # See table at https://en.wikipedia.org/wiki/UTF-8#Encoding + cond do + c in 0x00..0x7F -> 1 + c in 0x80..0x7FF -> 2 + c in 0x800..0xFFFF -> 3 + c in 0x1_0000..0x10_FFFF -> 4 + end + end +end diff --git a/engine/lib/engine/document.ex b/forge/lib/forge/document.ex similarity index 94% rename from engine/lib/engine/document.ex rename to forge/lib/forge/document.ex index da55a008..b5a6828b 100644 --- a/engine/lib/engine/document.ex +++ b/forge/lib/forge/document.ex @@ -1,20 +1,20 @@ -defmodule Engine.Document do +defmodule Forge.Document do @moduledoc """ A representation of a LSP text document - A document is the fundamental data structure of the Engine language server. + A document is the fundamental data structure of the Forge language server. All language server documents are represented and backed by documents, which provide functionality for fetching lines, applying changes, and tracking versions. """ - alias Engine.Convertible - alias Engine.Document.Edit - alias Engine.Document.Line - alias Engine.Document.Lines - alias Engine.Document.Position - alias Engine.Document.Range - alias Engine.Math + alias Forge.Convertible + alias Forge.Document.Edit + alias Forge.Document.Line + alias Forge.Document.Lines + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Math - import Engine.Document.Line + import Forge.Document.Line require Logger @@ -43,7 +43,7 @@ defmodule Engine.Document do Creates a new document from a uri or path, the source code as a binary and the vewrsion. """ - @spec new(Engine.path() | Engine.uri(), String.t(), version()) :: t + @spec new(Forge.path() | Forge.uri(), String.t(), version()) :: t def new(maybe_uri, text, version, language_id \\ nil) do uri = DocumentPath.ensure_uri(maybe_uri) path = DocumentPath.from_uri(uri) @@ -111,7 +111,7 @@ defmodule Engine.Document do end @doc """ - Get the `Engine>Document.Line` at the given index using `fetch` semantics. + Get the `Forge>Document.Line` at the given index using `fetch` semantics. This function is of limited utility, you probably want `fetch_text_at/2` instead. """ @@ -129,7 +129,7 @@ defmodule Engine.Document do Builds a string that represents the text of the document from the two positions given. The from position, defaults to `:beginning` meaning the start of the document. Positions can be a `Document.Position.t` or anything that will convert to a position using - `Engine.Convertible.to_native/2`. + `Forge.Convertible.to_native/2`. """ @spec fragment(t, fragment_position() | :beginning, fragment_position()) :: String.t() @spec fragment(t, fragment_position()) :: String.t() @@ -231,7 +231,7 @@ defmodule Engine.Document do |> IO.iodata_to_binary() end - @spec language_id_from_path(Engine.path()) :: String.t() + @spec language_id_from_path(Forge.path()) :: String.t() defp language_id_from_path(path) do case Path.extname(path) do ".ex" -> diff --git a/engine/lib/engine/document/changes.ex b/forge/lib/forge/document/changes.ex similarity index 86% rename from engine/lib/engine/document/changes.ex rename to forge/lib/forge/document/changes.ex index 323389ad..2911dd80 100644 --- a/engine/lib/engine/document/changes.ex +++ b/forge/lib/forge/document/changes.ex @@ -1,6 +1,6 @@ -defmodule Engine.Document.Changes do +defmodule Forge.Document.Changes do @moduledoc """ - A `Engine.Document.Container` for text edits. + A `Forge.Document.Container` for text edits. This struct is helpful if you need to express one or several text edits in an LSP response. It will convert cleanly into either a single `TextEdit` or a list of `TextEdit`s depending on @@ -10,9 +10,9 @@ defmodule Engine.Document.Changes do doesn't have to be looked up (and possibly read off the filesystem) by the language server. """ defstruct [:document, :edits] - alias Engine.Document + alias Forge.Document - use Engine.StructAccess + use Forge.StructAccess @type edits :: Document.Edit.t() | [Document.Edit.t()] @type t :: %__MODULE__{ diff --git a/engine/lib/engine/document/container.ex b/forge/lib/forge/document/container.ex similarity index 89% rename from engine/lib/engine/document/container.ex rename to forge/lib/forge/document/container.ex index 6df7f32d..1a9298ad 100644 --- a/engine/lib/engine/document/container.ex +++ b/forge/lib/forge/document/container.ex @@ -1,4 +1,4 @@ -defprotocol Engine.Document.Container do +defprotocol Forge.Document.Container do @moduledoc """ A protocol used to find relevant documents in structs @@ -13,11 +13,11 @@ defprotocol Engine.Document.Container do would _not_ need an implementation: ``` - %MyStruct{document: %Engine.Document{}} + %MyStruct{document: %Forge.Document{}} %MyStruct{text_document: %{uri: "file:///path/to/document.ex"}} ``` """ - alias Engine.Document + alias Forge.Document @fallback_to_any true @type maybe_context_document :: Document.t() | nil @@ -25,8 +25,8 @@ defprotocol Engine.Document.Container do def context_document(t, parent_context_document) end -defimpl Engine.Document.Container, for: Any do - alias Engine.Document +defimpl Forge.Document.Container, for: Any do + alias Forge.Document def context_document(%{document: %Document{} = document}, _) do document diff --git a/engine/lib/engine/document/edit.ex b/forge/lib/forge/document/edit.ex similarity index 80% rename from engine/lib/engine/document/edit.ex rename to forge/lib/forge/document/edit.ex index ccb52735..545947eb 100644 --- a/engine/lib/engine/document/edit.ex +++ b/forge/lib/forge/document/edit.ex @@ -1,12 +1,12 @@ -defmodule Engine.Document.Edit do +defmodule Forge.Document.Edit do @moduledoc """ A change to a document - A `Engine.Document.Edit` represents a single change to a document. It contains + A `Forge.Document.Edit` represents a single change to a document. It contains the new text and a range where the edit applies. """ - alias Engine.Document.Range - alias Engine.StructAccess + alias Forge.Document.Range + alias Forge.StructAccess defstruct [:text, :range] diff --git a/engine/lib/engine/document/line.ex b/forge/lib/forge/document/line.ex similarity index 95% rename from engine/lib/engine/document/line.ex rename to forge/lib/forge/document/line.ex index d70dd202..8d9ea409 100644 --- a/engine/lib/engine/document/line.ex +++ b/forge/lib/forge/document/line.ex @@ -1,4 +1,4 @@ -defmodule Engine.Document.Line do +defmodule Forge.Document.Line do @moduledoc ~S""" A record representing a line of text in a document diff --git a/engine/lib/engine/document/line_parser.ex b/forge/lib/forge/document/line_parser.ex similarity index 96% rename from engine/lib/engine/document/line_parser.ex rename to forge/lib/forge/document/line_parser.ex index 5826d217..575d4711 100644 --- a/engine/lib/engine/document/line_parser.ex +++ b/forge/lib/forge/document/line_parser.ex @@ -1,6 +1,6 @@ -defmodule Engine.Document.LineParser do +defmodule Forge.Document.LineParser do @moduledoc """ - A parser that parses a binary into `Engine.Document.Line` records. + A parser that parses a binary into `Forge.Document.Line` records. The approach taken by the parser is to first go through the binary to find out where the lines break, what their endings are and if the line is ascii. As we go through the @@ -12,7 +12,7 @@ defmodule Engine.Document.LineParser do each byte is greater than 0 and less than 128. UTF-16 files won't be marked as ascii, which allows us to skip a lot of byte conversions later in the process. """ - import Engine.Document.Line + import Forge.Document.Line # it's important that "\r\n" comes before \r here, otherwise the generated pattern # matches won't match. diff --git a/engine/lib/engine/document/lines.ex b/forge/lib/forge/document/lines.ex similarity index 92% rename from engine/lib/engine/document/lines.ex rename to forge/lib/forge/document/lines.ex index f023e21d..43126ee6 100644 --- a/engine/lib/engine/document/lines.ex +++ b/forge/lib/forge/document/lines.ex @@ -1,11 +1,11 @@ -defmodule Engine.Document.Lines do +defmodule Forge.Document.Lines do @moduledoc """ A hyper-optimized, line-based backing store for text documents """ - alias Engine.Document.Line - alias Engine.Document.LineParser + alias Forge.Document.Line + alias Forge.Document.LineParser - use Engine.StructAccess + use Forge.StructAccess import Line @default_starting_index 1 @@ -88,9 +88,9 @@ defmodule Engine.Document.Lines do end end -defimpl Inspect, for: Engine.Document.Lines do - alias Engine.Document.Lines - alias Engine.Document.Line +defimpl Inspect, for: Forge.Document.Lines do + alias Forge.Document.Lines + alias Forge.Document.Line import Inspect.Algebra import Line @@ -130,8 +130,8 @@ defimpl Inspect, for: Engine.Document.Lines do end end -defimpl Enumerable, for: Engine.Document.Lines do - alias Engine.Document.Lines +defimpl Enumerable, for: Forge.Document.Lines do + alias Forge.Document.Lines def count(%Lines{} = document) do {:ok, Lines.size(document)} diff --git a/engine/lib/engine/document/location.ex b/forge/lib/forge/document/location.ex similarity index 80% rename from engine/lib/engine/document/location.ex rename to forge/lib/forge/document/location.ex index a0aa4c63..73d00d55 100644 --- a/engine/lib/engine/document/location.ex +++ b/forge/lib/forge/document/location.ex @@ -1,22 +1,22 @@ -defmodule Engine.Document.Location do +defmodule Forge.Document.Location do @moduledoc """ A location in a document One of the fundamental LSP structures, this represents a subset of text in a document. - The location is bounded by the given range, and the document can be given as a `Engine.Document` + The location is bounded by the given range, and the document can be given as a `Forge.Document` struct, or a uri referencing the document """ - alias Engine.Document - alias Engine.Document.Range + alias Forge.Document + alias Forge.Document.Range defstruct [:range, :document, :uri] @type t :: %__MODULE__{ range: Range.t(), document: Document.t() | nil, - uri: Engine.uri() + uri: Forge.uri() } - use Engine.StructAccess + use Forge.StructAccess @spec new(Range.t(), Document.t() | String.t()) :: t() def new(%Range{} = range, %Document{} = document) do @@ -34,7 +34,7 @@ defmodule Engine.Document.Location do @doc """ Returns the location document's uri. """ - @spec uri(t) :: Engine.uri() + @spec uri(t) :: Forge.uri() def uri(%__MODULE__{} = location) do location.uri end diff --git a/engine/lib/engine/document/path.ex b/forge/lib/forge/document/path.ex similarity index 95% rename from engine/lib/engine/document/path.ex rename to forge/lib/forge/document/path.ex index f943298b..f0ecc120 100644 --- a/engine/lib/engine/document/path.ex +++ b/forge/lib/forge/document/path.ex @@ -1,15 +1,15 @@ -defmodule Engine.Document.Path do +defmodule Forge.Document.Path do @moduledoc """ A collection of functions dealing with converting filesystem paths to URIs and back """ @file_scheme "file" - @type uri_or_path :: Engine.uri() | Engine.path() + @type uri_or_path :: Forge.uri() | Forge.path() @doc """ Given a uri or a path, either return the uri unmodified or converts the path to a uri """ - @spec ensure_uri(uri_or_path()) :: Engine.uri() + @spec ensure_uri(uri_or_path()) :: Forge.uri() def ensure_uri("file://" <> _ = uri), do: uri def ensure_uri("untitled:" <> _ = uri), do: uri @@ -19,7 +19,7 @@ defmodule Engine.Document.Path do @doc """ Given a uri or a path, either return the path unmodified or converts the uri to a path """ - @spec ensure_path(uri_or_path()) :: Engine.path() + @spec ensure_path(uri_or_path()) :: Forge.path() def ensure_path("file://" <> _ = uri), do: from_uri(uri) def ensure_path(path) when is_binary(path), do: path diff --git a/engine/lib/engine/document/position.ex b/forge/lib/forge/document/position.ex similarity index 89% rename from engine/lib/engine/document/position.ex rename to forge/lib/forge/document/position.ex index b29f9d93..61c7d7b0 100644 --- a/engine/lib/engine/document/position.ex +++ b/forge/lib/forge/document/position.ex @@ -1,4 +1,4 @@ -defmodule Engine.Document.Position do +defmodule Forge.Document.Position do @moduledoc """ A position inside of a document @@ -9,11 +9,11 @@ defmodule Engine.Document.Position do Given the following line of text: "Hello there, welcome to lexical" - the position: `%Engine.Document.Position{line: 1, character: 1}` starts before the "H" in "Hello" + the position: `%Forge.Document.Position{line: 1, character: 1}` starts before the "H" in "Hello" """ - alias Engine.Document - alias Engine.Document.Lines + alias Forge.Document + alias Forge.Document.Lines defstruct [ :line, @@ -37,7 +37,7 @@ defmodule Engine.Document.Position do valid?: boolean() } - use Engine.StructAccess + use Forge.StructAccess @spec new(line_container(), line(), character()) :: t def new(%Document{} = document, line, character) @@ -100,7 +100,7 @@ defmodule Engine.Document.Position do end end -defimpl Inspect, for: Engine.Document.Position do +defimpl Inspect, for: Forge.Document.Position do import Inspect.Algebra def inspect(nil, _), do: "nil" @@ -110,7 +110,7 @@ defimpl Inspect, for: Engine.Document.Position do end end -defimpl String.Chars, for: Engine.Document.Position do +defimpl String.Chars, for: Forge.Document.Position do def to_string(pos) do "<<#{pos.line}, #{pos.character}>>" end diff --git a/engine/lib/engine/document/range.ex b/forge/lib/forge/document/range.ex similarity index 91% rename from engine/lib/engine/document/range.ex rename to forge/lib/forge/document/range.ex index e47f3b92..e7fb0075 100644 --- a/engine/lib/engine/document/range.ex +++ b/forge/lib/forge/document/range.ex @@ -1,4 +1,4 @@ -defmodule Engine.Document.Range do +defmodule Forge.Document.Range do @moduledoc """ A range in a document @@ -16,7 +16,7 @@ defmodule Engine.Document.Range do ) ``` """ - alias Engine.Document.Position + alias Forge.Document.Position defstruct start: nil, end: nil @@ -25,7 +25,7 @@ defmodule Engine.Document.Range do end: Position.t() } - use Engine.StructAccess + use Forge.StructAccess @doc """ Builds a new range. @@ -56,7 +56,7 @@ defmodule Engine.Document.Range do end end -defimpl Inspect, for: Engine.Document.Range do +defimpl Inspect, for: Forge.Document.Range do import Inspect.Algebra def inspect(range, _) do diff --git a/engine/lib/engine/document/store.ex b/forge/lib/forge/document/store.ex similarity index 87% rename from engine/lib/engine/document/store.ex rename to forge/lib/forge/document/store.ex index 2a233b07..70dfe144 100644 --- a/engine/lib/engine/document/store.ex +++ b/forge/lib/forge/document/store.ex @@ -1,10 +1,10 @@ -defmodule Engine.Document.Store do +defmodule Forge.Document.Store do @moduledoc """ Backing store for source file documents. """ - alias Engine.Document - alias Engine.ProcessCache + alias Forge.Document + alias Forge.ProcessCache use GenServer @@ -22,8 +22,8 @@ defmodule Engine.Document.Store do defmodule State do @moduledoc false - alias Engine.Document - alias Engine.Document.Store + alias Forge.Document + alias Forge.Document.Store require Logger @@ -52,7 +52,7 @@ defmodule Engine.Document.Store do %__MODULE__{derivation_funs: Map.new(derivation_funs)} end - @spec fetch(t, Engine.uri()) :: {:ok, Document.t(), t} | {:error, :not_open} + @spec fetch(t, Forge.uri()) :: {:ok, Document.t(), t} | {:error, :not_open} def fetch(%__MODULE__{} = store, uri) do case store.open do %{^uri => open_doc(document: document)} -> {:ok, document, store} @@ -60,7 +60,7 @@ defmodule Engine.Document.Store do end end - @spec fetch(t, Engine.uri(), Store.derivation_key()) :: + @spec fetch(t, Forge.uri(), Store.derivation_key()) :: {:ok, Document.t(), Store.derived_value(), t} | {:error, :not_open} def fetch(%__MODULE__{} = store, uri, key) do case store.open do @@ -78,7 +78,7 @@ defmodule Engine.Document.Store do end end - @spec save(t, Engine.uri()) :: {:ok, t} | {:error, :not_open} + @spec save(t, Forge.uri()) :: {:ok, t} | {:error, :not_open} def save(%__MODULE__{} = store, uri) do case store.open do %{^uri => open_doc(document: document, derived: derived)} -> @@ -91,7 +91,7 @@ defmodule Engine.Document.Store do end end - @spec open(t, Engine.uri(), String.t(), pos_integer(), String.t()) :: + @spec open(t, Forge.uri(), String.t(), pos_integer(), String.t()) :: {:ok, t} | {:error, :already_open} def open(%__MODULE__{temporary_open_refs: refs} = store, uri, text, version, language_id) when is_map_key(refs, uri) do @@ -115,12 +115,12 @@ defmodule Engine.Document.Store do end end - @spec open?(t, Engine.uri()) :: boolean + @spec open?(t, Forge.uri()) :: boolean def open?(%__MODULE__{} = store, uri) do Map.has_key?(store.open, uri) end - @spec close(t, Engine.uri()) :: {:ok, t} | {:error, :not_open} + @spec close(t, Forge.uri()) :: {:ok, t} | {:error, :not_open} def close(%__MODULE__{} = store, uri) do case pop_open_doc(store, uri) do {nil, _} -> @@ -131,7 +131,7 @@ defmodule Engine.Document.Store do end end - @spec get_and_update(t, Engine.uri(), Store.updater()) :: + @spec get_and_update(t, Forge.uri(), Store.updater()) :: {:ok, Document.t(), t} | {:error, any()} def get_and_update(%__MODULE__{} = store, uri, updater_fn) do with {:ok, open_doc(document: document)} <- Map.fetch(store.open, uri), @@ -143,14 +143,14 @@ defmodule Engine.Document.Store do end end - @spec update(t, Engine.uri(), Store.updater()) :: {:ok, t} | {:error, any()} + @spec update(t, Forge.uri(), Store.updater()) :: {:ok, t} | {:error, any()} def update(%__MODULE__{} = store, uri, updater_fn) do with {:ok, _, store} <- get_and_update(store, uri, updater_fn) do {:ok, store} end end - @spec open_temporarily(t, Engine.uri() | Path.t(), timeout()) :: + @spec open_temporarily(t, Forge.uri() | Path.t(), timeout()) :: {:ok, Document.t(), t} | {:error, term()} def open_temporarily(%__MODULE__{} = store, path_or_uri, timeout) do uri = Document.Path.ensure_uri(path_or_uri) @@ -170,7 +170,7 @@ defmodule Engine.Document.Store do end end - @spec extend_timeout(t, Engine.uri(), timeout()) :: t + @spec extend_timeout(t, Forge.uri(), timeout()) :: t def extend_timeout(%__MODULE__{} = store, uri, timeout) do case store.temporary_open_refs do %{^uri => ref} -> @@ -183,7 +183,7 @@ defmodule Engine.Document.Store do end end - @spec unload(t, Engine.uri()) :: t + @spec unload(t, Forge.uri()) :: t def unload(%__MODULE__{} = store, uri) do {_, store} = pop_open_doc(store, uri) maybe_cancel_ref(store, uri) @@ -236,37 +236,37 @@ defmodule Engine.Document.Store do end end - @spec fetch(Engine.uri()) :: {:ok, Document.t()} | {:error, :not_open} + @spec fetch(Forge.uri()) :: {:ok, Document.t()} | {:error, :not_open} def fetch(uri) do GenServer.call(name(), {:fetch, uri}) end - @spec fetch(Engine.uri(), derivation_key) :: + @spec fetch(Forge.uri(), derivation_key) :: {:ok, Document.t(), derived_value} | {:error, :not_open} def fetch(uri, key) do GenServer.call(name(), {:fetch, uri, key}) end - @spec save(Engine.uri()) :: :ok | {:error, :not_open} + @spec save(Forge.uri()) :: :ok | {:error, :not_open} def save(uri) do GenServer.call(name(), {:save, uri}) end - @spec open?(Engine.uri()) :: boolean() + @spec open?(Forge.uri()) :: boolean() def open?(uri) do GenServer.call(name(), {:open?, uri}) end - @spec open(Engine.uri(), String.t(), String.t(), pos_integer() | nil) :: + @spec open(Forge.uri(), String.t(), String.t(), pos_integer() | nil) :: :ok | {:error, :already_open} def open(uri, text, version, language_id \\ nil) do GenServer.call(name(), {:open, uri, text, version, language_id}) end - @spec open_temporary(Engine.uri() | Path.t()) :: + @spec open_temporary(Forge.uri() | Path.t()) :: {:ok, Document.t()} | {:error, term()} - @spec open_temporary(Engine.uri() | Path.t(), timeout()) :: + @spec open_temporary(Forge.uri() | Path.t(), timeout()) :: {:ok, Document.t()} | {:error, term()} def open_temporary(uri, timeout \\ 5000) when is_binary(uri) do ProcessCache.trans(uri, 50, fn -> @@ -274,17 +274,17 @@ defmodule Engine.Document.Store do end) end - @spec close(Engine.uri()) :: :ok | {:error, :not_open} + @spec close(Forge.uri()) :: :ok | {:error, :not_open} def close(uri) do GenServer.call(name(), {:close, uri}) end - @spec get_and_update(Engine.uri(), updater) :: {:ok, Document.t()} | {:error, any()} + @spec get_and_update(Forge.uri(), updater) :: {:ok, Document.t()} | {:error, any()} def get_and_update(uri, update_fn) do GenServer.call(name(), {:get_and_update, uri, update_fn}) end - @spec update(Engine.uri(), updater) :: :ok | {:error, any()} + @spec update(Forge.uri(), updater) :: :ok | {:error, any()} def update(uri, update_fn) do GenServer.call(name(), {:update, uri, update_fn}) end diff --git a/forge/lib/forge/identifier.ex b/forge/lib/forge/identifier.ex new file mode 100644 index 00000000..79e1464c --- /dev/null +++ b/forge/lib/forge/identifier.ex @@ -0,0 +1,27 @@ +defmodule Forge.Identifier do + @doc """ + Returns the next globally unique identifier. + Raises a MatchError if this cannot be computed. + """ + def next_global! do + {:ok, next_id} = Snowflake.next_id() + next_id + end + + def to_unix(id) do + Snowflake.Util.real_timestamp_of_id(id) + end + + def to_datetime(id) do + id + |> to_unix() + |> DateTime.from_unix!(:millisecond) + end + + def to_erl(id) do + %DateTime{year: year, month: month, day: day, hour: hour, minute: minute, second: second} = + to_datetime(id) + + {{year, month, day}, {hour, minute, second}} + end +end diff --git a/forge/lib/forge/plugin/v1/diagnostic/result.ex b/forge/lib/forge/plugin/v1/diagnostic/result.ex new file mode 100644 index 00000000..a0cd687c --- /dev/null +++ b/forge/lib/forge/plugin/v1/diagnostic/result.ex @@ -0,0 +1,105 @@ +defmodule Forge.Plugin.V1.Diagnostic.Result do + @moduledoc """ + The result of a diagnostic run + + A diagnostic plugin emits a list of `Result` structs that inform the user about issues + the plugin has found. The results contain the following keys: + + `uri` - The URI of the document where the error occurs. `Forge.Document` structs contain a + `uri` field which can be used to fill out this field. If you have a filesystem path, the function + `Forge.Document.Path.to_uri/1` can be used to transform a path to a URI. + + `message` - The diagnostic message displayed to the user + + `details` - Further details about the message + + `position` - Where the message occurred (see the `Positions` section for details) + + `severity` - How important the issue is. Can be one of (from least severe to most severe) + `:hint`, `:information`, `:warning`, `:error` + + `source` - The name of the plugin that produced this as a human-readable string. + + + ## Positions + + Diagnostics need to inform the language client where the error occurs. Positions are the + mechanism they use to do so. Positions take several forms, which are: + + `line number` - If the position is a one-based line number, the diagnostic will refer to + the entire flagged line + + `{line_number, column}` - If the position is a two-tuple of a one-based line number and a one-based + column, then the diagnostic will begin on the line indicated, and start at the column indicated. The + diagnostic will run to the end of the line. + + `{start_line, start_column, end_line, end_column}` - If the position is a four-tuple of of one-based + line and column numbers, the diagnostic will start on `start_line` at `start_column` and run until + `end_line` at `end_column`. This is the most detailed form of describing a position, and should be preferred + to the others, as it will produce the most accurate highlighting of the diagnostic. + + `Document.Range.t` - Equivalent to the {start_line, start_column, end_line, end_column}, but saves a + conversion step + + `Document.Position.t` - Equivalent to `{line_number, column}`, but saves a conversion step. + """ + alias Forge.Document + defstruct [:details, :message, :position, :severity, :source, :uri] + + @typedoc """ + A path or a uri. + """ + @type path_or_uri :: Forge.path() | Forge.uri() + + @typedoc """ + The severity of the diagnostic. + """ + @type severity :: :hint | :information | :warning | :error + + @typedoc false + @type mix_position :: + non_neg_integer() + | {pos_integer(), non_neg_integer()} + | {pos_integer(), non_neg_integer(), pos_integer(), non_neg_integer()} + + @typedoc """ + Where the error occurs in the document. + """ + @type position :: mix_position() | Document.Range.t() | Document.Position.t() + + @typedoc """ + A result emitted by a diagnostic plugin. + + These results are displayed in the editor to the user. + """ + @type t :: %__MODULE__{ + position: position, + message: iodata(), + severity: severity(), + source: String.t(), + uri: Forge.uri() + } + + @doc """ + Creates a new diagnostic result. + """ + @spec new(path_or_uri, position, iodata(), severity(), String.t()) :: t + @spec new(path_or_uri, position, iodata(), severity(), String.t(), any()) :: t + def new(maybe_uri_or_path, position, message, severity, source, details \\ nil) do + uri = + if maybe_uri_or_path do + Document.Path.ensure_uri(maybe_uri_or_path) + end + + message = IO.iodata_to_binary(message) + + %__MODULE__{ + uri: uri, + position: position, + message: message, + source: source, + severity: severity, + details: details + } + end +end diff --git a/engine/lib/engine/project.ex b/forge/lib/forge/project.ex similarity index 98% rename from engine/lib/engine/project.ex rename to forge/lib/forge/project.ex index 901a50be..32063ff5 100644 --- a/engine/lib/engine/project.ex +++ b/forge/lib/forge/project.ex @@ -1,4 +1,4 @@ -defmodule Engine.Project do +defmodule Forge.Project do @moduledoc """ The representation of the current state of an elixir project. @@ -19,8 +19,8 @@ defmodule Engine.Project do @type message :: String.t() @type restart_notification :: {:restart, Logger.level(), String.t()} @type t :: %__MODULE__{ - root_uri: Engine.uri() | nil, - mix_exs_uri: Engine.uri() | nil, + root_uri: Forge.uri() | nil, + mix_exs_uri: Forge.uri() | nil, entropy: non_neg_integer() # mix_env: atom(), # mix_target: atom(), @@ -31,7 +31,7 @@ defmodule Engine.Project do @workspace_directory_name ".lexical" # Public - @spec new(Engine.uri()) :: t + @spec new(Forge.uri()) :: t def new(root_uri) do entropy = :rand.uniform(65_536) diff --git a/engine/lib/engine/struct_access.ex b/forge/lib/forge/struct_access.ex similarity index 96% rename from engine/lib/engine/struct_access.ex rename to forge/lib/forge/struct_access.ex index bde5f26a..afb8919e 100644 --- a/engine/lib/engine/struct_access.ex +++ b/forge/lib/forge/struct_access.ex @@ -1,4 +1,4 @@ -defmodule Engine.StructAccess do +defmodule Forge.StructAccess do @moduledoc """ Allows structs to easily adopt the `Access` behaviour. """ diff --git a/forge/lib/forge/vm/versions.ex b/forge/lib/forge/vm/versions.ex new file mode 100644 index 00000000..9e33755d --- /dev/null +++ b/forge/lib/forge/vm/versions.ex @@ -0,0 +1,228 @@ +defmodule Forge.VM.Versions do + @moduledoc """ + Reads and writes version tags for elixir and erlang + + When compiling, it is important to node which version of the VM and elixir runtime + were used to build the beam files, as beam files compiled on a newer version of the + VM cannot be used on older versions. + + This module allows a directory to be tagged with the versions of elixir and erlang + used as compilation artifacts, and also allows the user to ask if a certain version + is compatible with the currently running VM. + """ + + @type version_string :: String.t() + + @type t :: %{elixir: version_string(), erlang: version_string()} + @type versioned_t :: %{elixir: Version.t(), erlang: Version.t()} + + @doc """ + Returns the versions of elixir and erlang in the currently running VM + """ + @spec current() :: t + def current do + %{ + elixir: elixir_version(), + erlang: erlang_version() + } + end + + @doc """ + Returns the compiled-in versions of elixir and erlang. + + This function uses the code server to find `.elixir` and `.erlang` files in the code path. + Each of these files represent the version of the runtime the artifact was compiled with. + """ + @spec compiled() :: {:ok, t} | {:error, term()} + def compiled do + with {:ok, elixir_path} <- code_find_file(version_file(:elixir)), + {:ok, erlang_path} <- code_find_file(version_file(:erlang)), + {:ok, elixir_version} <- read_file(elixir_path), + {:ok, erlang_version} <- read_file(erlang_path) do + {:ok, %{elixir: String.trim(elixir_version), erlang: String.trim(erlang_version)}} + end + end + + @doc """ + Converts the values of a version map into `Version` structs + """ + @spec to_versions(t) :: versioned_t() + def to_versions(%{elixir: elixir, erlang: erlang}) do + %{elixir: to_version(elixir), erlang: to_version(erlang)} + end + + @doc """ + Tells whether or not the current version of VM is supported by + Forge's compiled artifacts. + """ + @spec compatible?() :: boolean + @spec compatible?(Path.t()) :: boolean + def compatible? do + case code_find_file(version_file(:erlang)) do + {:ok, path} -> + path + |> Path.dirname() + |> compatible?() + + _ -> + false + end + end + + def compatible?(directory) do + system = current() + + case read(directory) do + {:ok, tagged} -> + system_erlang = to_version(system.erlang) + tagged_erlang = to_version(tagged.erlang) + + tagged_erlang.major <= system_erlang.major + + _ -> + false + end + end + + @doc """ + Returns true if the current directory has version tags for + both elixir and erlang in it. + """ + def tagged?(directory) do + with true <- File.exists?(version_file_path(directory, :elixir)) do + File.exists?(version_file_path(directory, :erlang)) + end + end + + @doc """ + Writes version tags in the given directory, overwriting any that are present + """ + def write(directory) do + write_erlang_version(directory) + write_elixir_version(directory) + end + + @doc """ + Reads all the version tags in the given directory. + This function will fail if one or both tags is missing + """ + def read(directory) do + with {:ok, elixir} <- read_elixir_version(directory), + {:ok, erlang} <- read_erlang_version(directory) do + {:ok, %{elixir: String.trim(elixir), erlang: String.trim(erlang)}} + end + end + + defp write_erlang_version(directory) do + directory + |> version_file_path(:erlang) + |> write_file!(erlang_version()) + end + + defp write_elixir_version(directory) do + directory + |> version_file_path(:elixir) + |> write_file!(elixir_version()) + end + + defp read_erlang_version(directory) do + directory + |> version_file_path(:erlang) + |> read_file() + end + + defp read_elixir_version(directory) do + directory + |> version_file_path(:elixir) + |> read_file() + end + + defp elixir_version do + System.version() + end + + defp erlang_version do + case :persistent_term.get({__MODULE__, :current_erlang}, :not_found) do + :not_found -> + major = :otp_release |> :erlang.system_info() |> List.to_string() + version_file = Path.join([:code.root_dir(), "releases", major, "OTP_VERSION"]) + + erlang_version = + try do + {:ok, contents} = read_file(version_file) + String.split(contents, "\n", trim: true) + else + [full] -> full + _ -> major + catch + :error -> + major + end + + :persistent_term.put({__MODULE__, :current_erlang}, erlang_version) + erlang_version() + + erlang_version -> + erlang_version + end + end + + defp version_file_path(directory, language) do + Path.join(directory, version_file(language)) + end + + defp version_file(language) do + ".#{language}" + end + + defp normalize(erlang_version) do + # Erlang doesn't use versions compabible with semantic versioning, + # this will make it compatible, as whatever the last number represents + # won't introduce vm-level incompatibilities. + + version_components = + erlang_version + |> String.split(".") + |> Enum.take(3) + + normalized = + case version_components do + [major] -> [major, "0", "0"] + [major, minor] -> [major, minor, "0"] + [_, _, _] = version -> version + [major, minor, patch | _] -> [major, minor, patch] + end + + Enum.join(normalized, ".") + end + + defp code_find_file(file_name) when is_binary(file_name) do + file_name + |> String.to_charlist() + |> code_find_file() + end + + defp code_find_file(file_name) when is_list(file_name) do + case :code.where_is_file(file_name) do + :non_existing -> + {:error, {:file_missing, file_name}} + + path -> + {:ok, List.to_string(path)} + end + end + + defp to_version(version) when is_binary(version) do + version |> normalize() |> Version.parse!() + end + + # these functions exist for testing. I was getting process killed with + # patch if we patch the File module directly + defp write_file!(path, contents) do + File.write!(path, contents) + end + + defp read_file(path) do + File.read(path) + end +end diff --git a/forge/lib/future/code.ex b/forge/lib/future/code.ex new file mode 100644 index 00000000..c14ec8a6 --- /dev/null +++ b/forge/lib/future/code.ex @@ -0,0 +1,2095 @@ +# Copied from https://github.com/elixir-lang/elixir/blob/bacea2cef6323d0ede4222f36ddcedd82cb514e4/lib/elixir/lib/code.ex +# I commented print_diagnostic/1, because it is not used in the codebase. +# And I changed string_to_quoted/2 to make it use :future_elixir +defmodule Future.Code do + @moduledoc ~S""" + Utilities for managing code compilation, code evaluation, and code loading. + + This module complements Erlang's [`:code` module](`:code`) + to add behaviour which is specific to Elixir. For functions to + manipulate Elixir's AST (rather than evaluating it), see the + `Macro` module. + + ## Working with files + + This module contains three functions for compiling and evaluating files. + Here is a summary of them and their behaviour: + + * `require_file/2` - compiles a file and tracks its name. It does not + compile the file again if it has been previously required. + + * `compile_file/2` - compiles a file without tracking its name. Compiles the + file multiple times when invoked multiple times. + + * `eval_file/2` - evaluates the file contents without tracking its name. It + returns the result of the last expression in the file, instead of the modules + defined in it. Evaluated files do not trigger the compilation tracers described + in the next section. + + In a nutshell, the first must be used when you want to keep track of the files + handled by the system, to avoid the same file from being compiled multiple + times. This is common in scripts. + + `compile_file/2` must be used when you are interested in the modules defined in a + file, without tracking. `eval_file/2` should be used when you are interested in + the result of evaluating the file rather than the modules it defines. + + The functions above work with Elixir source. If you want to work + with modules compiled to bytecode, which have the `.beam` extension + and are typically found below the _build directory of a Mix project, + see the functions in Erlang's [`:code`](`:code`) module. + + ## Code loading on the Erlang VM + + Erlang has two modes to load code: interactive and embedded. + + By default, the Erlang VM runs in interactive mode, where modules + are loaded as needed. In embedded mode the opposite happens, as all + modules need to be loaded upfront or explicitly. + + You can use `ensure_loaded/1` (as well as `ensure_loaded?/1` and + `ensure_loaded!/1`) to check if a module is loaded before using it and + act. + + ## `ensure_compiled/1` and `ensure_compiled!/1` + + Elixir also includes `ensure_compiled/1` and `ensure_compiled!/1` + functions that are a superset of `ensure_loaded/1`. + + Since Elixir's compilation happens in parallel, in some situations + you may need to use a module that was not yet compiled, therefore + it can't even be loaded. + + When invoked, `ensure_compiled/1` and `ensure_compiled!/1` halt the + compilation of the caller until the module becomes available. Note that + the distinction between `ensure_compiled/1` and `ensure_compiled!/1` + is important: if you are using `ensure_compiled!/1`, you are + indicating to the compiler that you can only continue if said module + is available. + + If you are using `Code.ensure_compiled/1`, you are implying you may + continue without the module and therefore Elixir may return + `{:error, :unavailable}` for cases where the module is not yet available + (but may be available later on). + + For those reasons, developers must typically use `Code.ensure_compiled!/1`. + In particular, do not do this: + + case Code.ensure_compiled(module) do + {:module, _} -> module + {:error, _} -> raise ... + end + + Finally, note you only need `ensure_compiled!/1` to check for modules + being defined within the same project. It does not apply to modules from + dependencies as dependencies are always compiled upfront. + + In most cases, `ensure_loaded/1` is enough. `ensure_compiled!/1` + must be used in rare cases, usually involving macros that need to + invoke a module for callback information. The use of `ensure_compiled/1` + is even less likely. + + ## Compilation tracers + + Elixir supports compilation tracers, which allow modules to observe constructs + handled by the Elixir compiler when compiling files. A tracer is a module + that implements the `trace/2` function. The function receives the event name + as first argument and `Macro.Env` as second and it must return `:ok`. It is + very important for a tracer to do as little work as possible synchronously + and dispatch the bulk of the work to a separate process. **Slow tracers will + slow down compilation**. + + You can configure your list of tracers via `put_compiler_option/2`. The + following events are available to tracers: + + * `:start` - (since v1.11.0) invoked whenever the compiler starts to trace + a new lexical context. A lexical context is started when compiling a new + file or when defining a module within a function. Note evaluated code + does not start a new lexical context (because they don't track unused + aliases, imports, etc) but defining a module inside evaluated code will. + + Note this event may be emitted in parallel, where multiple files/modules + invoke `:start` and run at the same time. The value of the `lexical_tracker` + of the macro environment, albeit opaque, can be used to uniquely identify + the environment. + + * `:stop` - (since v1.11.0) invoked whenever the compiler stops tracing a + new lexical context, such as a new file. + + * `{:import, meta, module, opts}` - traced whenever `module` is imported. + `meta` is the import AST metadata and `opts` are the import options. + + * `{:imported_function, meta, module, name, arity}` and + `{:imported_macro, meta, module, name, arity}` - traced whenever an + imported function or macro is invoked. `meta` is the call AST metadata, + `module` is the module the import is from, followed by the `name` and `arity` + of the imported function/macro. A :remote_function/:remote_macro event + may still be emitted for the imported module/name/arity. + + * `{:alias, meta, alias, as, opts}` - traced whenever `alias` is aliased + to `as`. `meta` is the alias AST metadata and `opts` are the alias options. + + * `{:alias_expansion, meta, as, alias}` traced whenever there is an alias + expansion for a previously defined `alias`, i.e. when the user writes `as` + which is expanded to `alias`. `meta` is the alias expansion AST metadata. + + * `{:alias_reference, meta, module}` - traced whenever there is an alias + in the code, i.e. whenever the user writes `MyModule.Foo.Bar` in the code, + regardless if it was expanded or not. + + * `{:require, meta, module, opts}` - traced whenever `module` is required. + `meta` is the require AST metadata and `opts` are the require options. + If the `meta` option contains the `:from_macro`, then module was called + from within a macro and therefore must be treated as a compile-time dependency. + + * `{:struct_expansion, meta, module, keys}` - traced whenever `module`'s struct + is expanded. `meta` is the struct AST metadata and `keys` are the keys being + used by expansion + + * `{:remote_function, meta, module, name, arity}` and + `{:remote_macro, meta, module, name, arity}` - traced whenever a remote + function or macro is referenced. `meta` is the call AST metadata, `module` + is the invoked module, followed by the `name` and `arity`. + + * `{:local_function, meta, name, arity}` and + `{:local_macro, meta, name, arity}` - traced whenever a local + function or macro is referenced. `meta` is the call AST metadata, followed by + the `name` and `arity`. + + * `{:compile_env, app, path, return}` - traced whenever `Application.compile_env/3` + or `Application.compile_env!/2` are called. `app` is an atom, `path` is a list + of keys to traverse in the application environment and `return` is either + `{:ok, value}` or `:error`. + + * `{:on_module, bytecode, _ignore}` - (since v1.13.0) traced whenever a module + is defined. This is equivalent to the `@after_compile` callback and invoked + after any `@after_compile` in the given module. The third element is currently + `:none` but it may provide more metadata in the future. It is best to ignore + it at the moment. Note that `Module` functions expecting not yet compiled modules + (such as `Module.definitions_in/1`) are still available at the time this event + is emitted. + + The `:tracers` compiler option can be combined with the `:parser_options` + compiler option to enrich the metadata of the traced events above. + + New events may be added at any time in the future, therefore it is advised + for the `trace/2` function to have a "catch-all" clause. + + Below is an example tracer that prints all remote function invocations: + + defmodule MyTracer do + def trace({:remote_function, _meta, module, name, arity}, env) do + IO.puts "#{env.file}:#{env.line} #{inspect(module)}.#{name}/#{arity}" + :ok + end + + def trace(_event, _env) do + :ok + end + end + """ + + @typedoc """ + A list with all variables and their values. + + The binding keys are usually atoms, but they may be a tuple for variables + defined in a different context. + """ + @type binding :: [{atom() | tuple(), any}] + + @typedoc """ + Diagnostics returned by the compiler and code evaluation. + """ + @type diagnostic(severity) :: %{ + required(:file) => Path.t(), + required(:severity) => severity, + required(:message) => String.t(), + required(:position) => position, + required(:stacktrace) => Exception.stacktrace(), + optional(any()) => any() + } + + @typedoc "The line. 0 indicates no line." + @type line() :: non_neg_integer() + @type position() :: line() | {pos_integer(), column :: non_neg_integer} + + @boolean_compiler_options [ + :docs, + :debug_info, + :ignore_already_consolidated, + :ignore_module_conflict, + :relative_paths, + :warnings_as_errors + ] + + @list_compiler_options [:no_warn_undefined, :tracers, :parser_options] + + @available_compiler_options @boolean_compiler_options ++ + @list_compiler_options ++ [:on_undefined_variable] + + @doc """ + Lists all required files. + + ## Examples + + Code.require_file("../eex/test/eex_test.exs") + List.first(Code.required_files()) =~ "eex_test.exs" + #=> true + + """ + @doc since: "1.7.0" + @spec required_files() :: [binary] + def required_files do + :elixir_code_server.call(:required) + end + + @deprecated "Use Code.required_files/0 instead" + @doc false + def loaded_files do + required_files() + end + + @doc false + @deprecated "Use Code.Fragment.cursor_context/2 instead" + def cursor_context(code, options \\ []) do + Code.Fragment.cursor_context(code, options) + end + + @doc """ + Removes files from the required files list. + + The modules defined in the file are not removed; + calling this function only removes them from the list, + allowing them to be required again. + + The list of files is managed per Erlang VM node. + + ## Examples + + # Require EEx test code + Code.require_file("../eex/test/eex_test.exs") + + # Now unrequire all files + Code.unrequire_files(Code.required_files()) + + # Note that modules are still available + function_exported?(EExTest.Compiled, :before_compile, 0) + #=> true + + """ + @doc since: "1.7.0" + @spec unrequire_files([binary]) :: :ok + def unrequire_files(files) when is_list(files) do + :elixir_code_server.cast({:unrequire_files, files}) + end + + @deprecated "Use Code.unrequire_files/1 instead" + @doc false + def unload_files(files) do + unrequire_files(files) + end + + @doc """ + Appends a path to the Erlang VM code path list. + + This is the list of directories the Erlang VM uses for + finding module code. The list of files is managed per Erlang + VM node. + + The path is expanded with `Path.expand/1` before being appended. + It requires the path to exist. Returns a boolean indicating if + the path was successfully added. + + ## Examples + + Code.append_path(".") + #=> true + + Code.append_path("/does_not_exist") + #=> false + + ## Options + + * `:cache` - (since v1.15.0) when true, the code path is cached + the first time it is traversed in order to reduce file system + operations. It requires Erlang/OTP 26, otherwise it is a no-op. + + """ + @spec append_path(Path.t(), cache: boolean()) :: true | false + def append_path(path, opts \\ []) do + apply(:code, :add_pathz, [to_charlist(Path.expand(path)) | cache(opts)]) == true + end + + @doc """ + Prepends a path to the Erlang VM code path list. + + This is the list of directories the Erlang VM uses for + finding module code. The list of files is managed per Erlang + VM node. + + The path is expanded with `Path.expand/1` before being prepended. + It requires the path to exist. Returns a boolean indicating if + the path was successfully added. + + ## Examples + + Code.prepend_path(".") + #=> true + + Code.prepend_path("/does_not_exist") + #=> false + + ## Options + + * `:cache` - (since v1.15.0) when true, the code path is cached + the first time it is traversed in order to reduce file system + operations. It requires Erlang/OTP 26, otherwise it is a no-op. + + """ + @spec prepend_path(Path.t(), cache: boolean()) :: boolean() + def prepend_path(path, opts \\ []) do + apply(:code, :add_patha, [to_charlist(Path.expand(path)) | cache(opts)]) == true + end + + @doc """ + Prepends a list of `paths` to the Erlang VM code path list. + + This is the list of directories the Erlang VM uses for + finding module code. The list of files is managed per Erlang + VM node. + + All paths are expanded with `Path.expand/1` before being prepended. + Only existing paths are prepended. This function always returns `:ok`, + regardless of how many paths were prepended. Use `prepend_path/1` + if you need more control. + + ## Examples + + Code.prepend_paths([".", "/does_not_exist"]) + #=> :ok + + ## Options + + * `:cache` - when true, the code path is cached the first time + it is traversed in order to reduce file system operations. + It requires Erlang/OTP 26, otherwise it is a no-op. + """ + @doc since: "1.15.0" + @spec prepend_paths([Path.t()], cache: boolean()) :: :ok + def prepend_paths(paths, opts \\ []) when is_list(paths) do + apply(:code, :add_pathsa, [Enum.map(paths, &to_charlist(Path.expand(&1))) | cache(opts)]) + end + + @doc """ + Appends a list of `paths` to the Erlang VM code path list. + + This is the list of directories the Erlang VM uses for + finding module code. The list of files is managed per Erlang + VM node. + + All paths are expanded with `Path.expand/1` before being appended. + Only existing paths are appended. This function always returns `:ok`, + regardless of how many paths were appended. Use `append_path/1` + if you need more control. + + ## Examples + + Code.append_paths([".", "/does_not_exist"]) + #=> :ok + + ## Options + + * `:cache` - when true, the code path is cached the first time + it is traversed in order to reduce file system operations. + It requires Erlang/OTP 26, otherwise it is a no-op. + """ + @doc since: "1.15.0" + @spec append_paths([Path.t()], cache: boolean()) :: :ok + def append_paths(paths, opts \\ []) when is_list(paths) do + apply(:code, :add_pathsz, [Enum.map(paths, &to_charlist(Path.expand(&1))) | cache(opts)]) + end + + defp cache(opts) do + if function_exported?(:code, :add_path, 2) do + if opts[:cache], do: [:cache], else: [:nocache] + else + [] + end + end + + @doc """ + Deletes a path from the Erlang VM code path list. + + This is the list of directories the Erlang VM uses for finding + module code. The list of files is managed per Erlang VM node. + + The path is expanded with `Path.expand/1` before being deleted. If the + path does not exist, this function returns `false`. + + ## Examples + + Code.prepend_path(".") + Code.delete_path(".") + #=> true + + Code.delete_path("/does_not_exist") + #=> false + + """ + @spec delete_path(Path.t()) :: boolean + def delete_path(path) do + case :code.del_path(to_charlist(Path.expand(path))) do + result when is_boolean(result) -> + result + + {:error, :bad_name} -> + raise ArgumentError, + "invalid argument #{inspect(path)}" + end + end + + @doc """ + Deletes a list of paths from the Erlang VM code path list. + + This is the list of directories the Erlang VM uses for finding + module code. The list of files is managed per Erlang VM node. + + The path is expanded with `Path.expand/1` before being deleted. If the + path does not exist, this function returns `false`. + """ + @doc since: "1.15.0" + @spec delete_paths([Path.t()]) :: :ok + def delete_paths(paths) when is_list(paths) do + for path <- paths do + _ = :code.del_path(to_charlist(Path.expand(path))) + end + + :ok + end + + @doc """ + Evaluates the contents given by `string`. + + The `binding` argument is a list of all variables and their values. + The `opts` argument is a keyword list of environment options. + + **Warning**: `string` can be any Elixir code and will be executed with + the same privileges as the Erlang VM: this means that such code could + compromise the machine (for example by executing system commands). + Don't use `eval_string/3` with untrusted input (such as strings coming + from the network). + + ## Options + + Options can be: + + * `:file` - the file to be considered in the evaluation + + * `:line` - the line on which the script starts + + Additionally, you may also pass an environment as second argument, + so the evaluation happens within that environment. + + Returns a tuple of the form `{value, binding}`, where `value` is the value + returned from evaluating `string`. If an error occurs while evaluating + `string`, an exception will be raised. + + `binding` is a list with all variable names and their values after evaluating + `string`. The binding keys are usually atoms, but they may be a tuple for variables + defined in a different context. The names are in no particular order. + + ## Examples + + iex> {result, binding} = Code.eval_string("a + b", [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line) + iex> result + 3 + iex> Enum.sort(binding) + [a: 1, b: 2] + + iex> {result, binding} = Code.eval_string("c = a + b", [a: 1, b: 2], __ENV__) + iex> result + 3 + iex> Enum.sort(binding) + [a: 1, b: 2, c: 3] + + iex> {result, binding} = Code.eval_string("a = a + b", [a: 1, b: 2]) + iex> result + 3 + iex> Enum.sort(binding) + [a: 3, b: 2] + + For convenience, you can pass `__ENV__/0` as the `opts` argument and + all imports, requires and aliases defined in the current environment + will be automatically carried over: + + iex> {result, binding} = Code.eval_string("a + b", [a: 1, b: 2], __ENV__) + iex> result + 3 + iex> Enum.sort(binding) + [a: 1, b: 2] + + """ + @spec eval_string(List.Chars.t(), binding, Macro.Env.t() | keyword) :: {term, binding} + def eval_string(string, binding \\ [], opts \\ []) + + def eval_string(string, binding, %Macro.Env{} = env) do + validated_eval_string(string, binding, env) + end + + def eval_string(string, binding, opts) when is_list(opts) do + validated_eval_string(string, binding, opts) + end + + defp validated_eval_string(string, binding, opts_or_env) do + %{line: line, file: file} = env = env_for_eval(opts_or_env) + forms = :future_elixir.string_to_quoted!(to_charlist(string), line, 1, file, []) + {value, binding, _env} = eval_verify(:eval_forms, [forms, binding, env]) + {value, binding} + end + + defp eval_verify(fun, args) do + Module.ParallelChecker.verify(fn -> + apply(:elixir, fun, args) + end) + end + + @doc """ + Executes the given `fun` and capture all diagnostics. + + Diagnostics are warnings and errors emitted by the compiler + and by functions such as `IO.warn/2`. + + ## Options + + * `:log` - if the diagnostics should be logged as they happen. + Defaults to `false`. + + """ + @doc since: "1.15.0" + @spec with_diagnostics(keyword(), (-> result)) :: {result, [diagnostic(:warning | :error)]} + when result: term() + def with_diagnostics(opts \\ [], fun) do + value = :erlang.get(:elixir_code_diagnostics) + log = Keyword.get(opts, :log, false) + :erlang.put(:elixir_code_diagnostics, {[], log}) + + try do + result = fun.() + {diagnostics, _log?} = :erlang.get(:elixir_code_diagnostics) + {result, Enum.reverse(diagnostics)} + after + if value == :undefined do + :erlang.erase(:elixir_code_diagnostics) + else + :erlang.put(:elixir_code_diagnostics, value) + end + end + end + + # @doc """ + # Prints a diagnostic into the standard error. + # + # A diagnostic is either returned by `Kernel.ParallelCompiler` + # or by `Code.with_diagnostics/2`. + # """ + # @doc since: "1.15.0" + # @spec print_diagnostic(diagnostic(:warning | :error)) :: :ok + # def print_diagnostic(diagnostic) do + # :elixir_errors.print_diagnostic(diagnostic) + # :ok + # end + + @doc ~S""" + Formats the given code `string`. + + The formatter receives a string representing Elixir code and + returns iodata representing the formatted code according to + pre-defined rules. + + ## Options + + * `:file` - the file which contains the string, used for error + reporting + + * `:line` - the line the string starts, used for error reporting + + * `:line_length` - the line length to aim for when formatting + the document. Defaults to 98. Note this value is used as + guideline but there are situations where it is not enforced. + See the "Line length" section below for more information + + * `:locals_without_parens` - a keyword list of name and arity + pairs that should be kept without parens whenever possible. + The arity may be the atom `:*`, which implies all arities of + that name. The formatter already includes a list of functions + and this option augments this list. + + * `:force_do_end_blocks` (since v1.9.0) - when `true`, converts all + inline usages of `do: ...`, `else: ...` and friends into `do`-`end` + blocks. Defaults to `false`. Note that this option is convergent: + once you set it to `true`, **all keywords** will be converted. + If you set it to `false` later on, `do`-`end` blocks won't be + converted back to keywords. + + * `:normalize_bitstring_modifiers` (since v1.14.0) - when `true`, + removes unnecessary parentheses in known bitstring + [modifiers](`<<>>/1`), for example `<>` + becomes `<>`, or adds parentheses for custom + modifiers, where `<>` becomes `<>`. + Defaults to `true`. This option changes the AST. + + * `:normalize_charlists_as_sigils` (since v1.15.0) - when `true`, + formats charlists as [`~c`](`Kernel.sigil_c/2`) sigils, for example + `'foo'` becomes `~c"foo"`. + Defaults to `true`. This option changes the AST. + + ## Design principles + + The formatter was designed under three principles. + + First, the formatter never changes the semantics of the code. + This means the input AST and the output AST are almost always equivalent. + The only cases where the formatter will change the AST is when the input AST + would cause *compiler warnings* and the output AST won't. The cases where + the formatter changes the AST can be disabled through formatting options + if desired. + + The second principle is to provide as little configuration as possible. + This eases the formatter adoption by removing contention points while + making sure a single style is followed consistently by the community as + a whole. + + The formatter does not hard code names. The formatter will not behave + specially because a function is named `defmodule`, `def`, or the like. This + principle mirrors Elixir's goal of being an extensible language where + developers can extend the language with new constructs as if they were + part of the language. When it is absolutely necessary to change behaviour + based on the name, this behaviour should be configurable, such as the + `:locals_without_parens` option. + + ## Running the formatter + + The formatter attempts to fit the most it can on a single line and + introduces line breaks wherever possible when it cannot. + + In some cases, this may lead to undesired formatting. Therefore, **some + code generated by the formatter may not be aesthetically pleasing and + may require explicit intervention from the developer**. That's why we + do not recommend to run the formatter blindly in an existing codebase. + Instead you should format and sanity check each formatted file. + + For example, the formatter may break a long function definition over + multiple clauses: + + def my_function( + %User{name: name, age: age, ...}, + arg1, + arg2 + ) do + ... + end + + While the code above is completely valid, you may prefer to match on + the struct variables inside the function body in order to keep the + definition on a single line: + + def my_function(%User{} = user, arg1, arg2) do + %{name: name, age: age, ...} = user + ... + end + + In some situations, you can use the fact the formatter does not generate + elegant code as a hint for refactoring. Take this code: + + def board?(board_id, %User{} = user, available_permissions, required_permissions) do + Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and + required_permissions == Enum.to_list(MapSet.intersection(MapSet.new(required_permissions), MapSet.new(available_permissions))) + end + + The code above has very long lines and running the formatter is not going + to address this issue. In fact, the formatter may make it more obvious that + you have complex expressions: + + def board?(board_id, %User{} = user, available_permissions, required_permissions) do + Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and + required_permissions == + Enum.to_list( + MapSet.intersection( + MapSet.new(required_permissions), + MapSet.new(available_permissions) + ) + ) + end + + Take such cases as a suggestion that your code should be refactored: + + def board?(board_id, %User{} = user, available_permissions, required_permissions) do + Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and + matching_permissions?(required_permissions, available_permissions) + end + + defp matching_permissions?(required_permissions, available_permissions) do + intersection = + required_permissions + |> MapSet.new() + |> MapSet.intersection(MapSet.new(available_permissions)) + |> Enum.to_list() + + required_permissions == intersection + end + + To sum it up: since the formatter cannot change the semantics of your + code, sometimes it is necessary to tweak or refactor the code to get + optimal formatting. To help better understand how to control the formatter, + we describe in the next sections the cases where the formatter keeps the + user encoding and how to control multiline expressions. + + ## Line length + + Another point about the formatter is that the `:line_length` configuration + is a guideline. In many cases, it is not possible for the formatter to break + your code apart, which means it will go over the line length. For example, + if you have a long string: + + "this is a very long string that will go over the line length" + + The formatter doesn't know how to break it apart without changing the + code underlying syntax representation, so it is up to you to step in: + + "this is a very long string " <> + "that will go over the line length" + + The string concatenation makes the code fit on a single line and also + gives more options to the formatter. + + This may also appear in do/end blocks, where the `do` keyword (or `->`) + may go over the line length because there is no opportunity for the + formatter to introduce a line break in a readable way. For example, + if you do: + + case very_long_expression() do + end + + And only the `do` keyword is above the line length, Elixir **will not** + emit this: + + case very_long_expression() + do + end + + So it prefers to not touch the line at all and leave `do` above the + line limit. + + ## Keeping user's formatting + + The formatter respects the input format in some cases. Those are + listed below: + + * Insignificant digits in numbers are kept as is. The formatter, + however, always inserts underscores for decimal numbers with more + than 5 digits and converts hexadecimal digits to uppercase + + * Strings, charlists, atoms and sigils are kept as is. No character + is automatically escaped or unescaped. The choice of delimiter is + also respected from the input + + * Newlines inside blocks are kept as in the input except for: + 1) expressions that take multiple lines will always have an empty + line before and after and 2) empty lines are always squeezed + together into a single empty line + + * The choice between `:do` keyword and `do`-`end` blocks is left + to the user + + * Lists, tuples, bitstrings, maps, structs and function calls will be + broken into multiple lines if they are followed by a newline in the + opening bracket and preceded by a new line in the closing bracket + + * Newlines before certain operators (such as the pipeline operators) + and before other operators (such as comparison operators) + + The behaviours above are not guaranteed. We may remove or add new + rules in the future. The goal of documenting them is to provide better + understanding on what to expect from the formatter. + + ### Multi-line lists, maps, tuples, and the like + + You can force lists, tuples, bitstrings, maps, structs and function + calls to have one entry per line by adding a newline after the opening + bracket and a new line before the closing bracket lines. For example: + + [ + foo, + bar + ] + + If there are no newlines around the brackets, then the formatter will + try to fit everything on a single line, such that the snippet below + + [foo, + bar] + + will be formatted as + + [foo, bar] + + You can also force function calls and keywords to be rendered on multiple + lines by having each entry on its own line: + + defstruct name: nil, + age: 0 + + The code above will be kept with one keyword entry per line by the + formatter. To avoid that, just squash everything into a single line. + + ### Parens and no parens in function calls + + Elixir has two syntaxes for function calls. With parens and no parens. + By default, Elixir will add parens to all calls except for: + + 1. calls that have `do`-`end` blocks + 2. local calls without parens where the name and arity of the local + call is also listed under `:locals_without_parens` (except for + calls with arity 0, where the compiler always require parens) + + The choice of parens and no parens also affects indentation. When a + function call with parens doesn't fit on the same line, the formatter + introduces a newline around parens and indents the arguments with two + spaces: + + some_call( + arg1, + arg2, + arg3 + ) + + On the other hand, function calls without parens are always indented + by the function call length itself, like this: + + some_call arg1, + arg2, + arg3 + + If the last argument is a data structure, such as maps and lists, and + the beginning of the data structure fits on the same line as the function + call, then no indentation happens, this allows code like this: + + Enum.reduce(some_collection, initial_value, fn element, acc -> + # code + end) + + some_function_without_parens %{ + foo: :bar, + baz: :bat + } + + ## Code comments + + The formatter also handles code comments in a way to guarantee a space + is always added between the beginning of the comment (#) and the next + character. + + The formatter also extracts all trailing comments to their previous line. + For example, the code below + + hello #world + + will be rewritten to + + # world + hello + + Because code comments are handled apart from the code representation (AST), + there are some situations where code comments are seen as ambiguous by the + code formatter. For example, the comment in the anonymous function below + + fn + arg1 -> + body1 + # comment + + arg2 -> + body2 + end + + and in this one + + fn + arg1 -> + body1 + + # comment + arg2 -> + body2 + end + + are considered equivalent (the nesting is discarded alongside most of + user formatting). In such cases, the code formatter will always format to + the latter. + + ## Newlines + + The formatter converts all newlines in code from `\r\n` to `\n`. + """ + @doc since: "1.6.0" + @spec format_string!(binary, keyword) :: iodata + def format_string!(string, opts \\ []) when is_binary(string) and is_list(opts) do + line_length = Keyword.get(opts, :line_length, 98) + + to_quoted_opts = + [ + unescape: false, + warn_on_unnecessary_quotes: false, + literal_encoder: &{:ok, {:__block__, &2, [&1]}}, + token_metadata: true, + warnings: false + ] ++ opts + + {forms, comments} = string_to_quoted_with_comments!(string, to_quoted_opts) + to_algebra_opts = [comments: comments] ++ opts + doc = Code.Formatter.to_algebra(forms, to_algebra_opts) + Inspect.Algebra.format(doc, line_length) + end + + @doc """ + Formats a file. + + See `format_string!/2` for more information on code formatting and + available options. + """ + @doc since: "1.6.0" + @spec format_file!(binary, keyword) :: iodata + def format_file!(file, opts \\ []) when is_binary(file) and is_list(opts) do + string = File.read!(file) + formatted = format_string!(string, [file: file, line: 1] ++ opts) + [formatted, ?\n] + end + + @doc """ + Evaluates the quoted contents. + + **Warning**: Calling this function inside a macro is considered bad + practice as it will attempt to evaluate runtime values at compile time. + Macro arguments are typically transformed by unquoting them into the + returned quoted expressions (instead of evaluated). + + See `eval_string/3` for a description of `binding` and `opts`. + + ## Examples + + iex> contents = quote(do: var!(a) + var!(b)) + iex> {result, binding} = Code.eval_quoted(contents, [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line) + iex> result + 3 + iex> Enum.sort(binding) + [a: 1, b: 2] + + For convenience, you can pass `__ENV__/0` as the `opts` argument and + all options will be automatically extracted from the current environment: + + iex> contents = quote(do: var!(a) + var!(b)) + iex> {result, binding} = Code.eval_quoted(contents, [a: 1, b: 2], __ENV__) + iex> result + 3 + iex> Enum.sort(binding) + [a: 1, b: 2] + + """ + @spec eval_quoted(Macro.t(), binding, Macro.Env.t() | keyword) :: {term, binding} + def eval_quoted(quoted, binding \\ [], env_or_opts \\ []) do + {value, binding, _env} = + eval_verify(:eval_quoted, [quoted, binding, env_for_eval(env_or_opts)]) + + {value, binding} + end + + @doc """ + Returns an environment for evaluation. + + It accepts either a `Macro.Env`, that is then pruned and prepared, + or a list of options. It returns an environment that is ready for + evaluation. + + Most functions in this module will automatically prepare the given + environment for evaluation, so you don't need to explicitly call + this function, with the exception of `eval_quoted_with_env/3`, + which was designed precisely to be called in a loop, to implement + features such as interactive shells or anything else with multiple + evaluations. + + ## Options + + If an env is not given, the options can be: + + * `:file` - the file to be considered in the evaluation + + * `:line` - the line on which the script starts + """ + @doc since: "1.14.0" + def env_for_eval(env_or_opts), do: :elixir.env_for_eval(env_or_opts) + + @doc """ + Evaluates the given `quoted` contents with `binding` and `env`. + + This function is meant to be called in a loop, to implement features + such as interactive shells or anything else with multiple evaluations. + Therefore, the first time you call this function, you must compute + the initial environment with `env_for_eval/1`. The remaining calls + must pass the environment that was returned by this function. + + ## Options + + * `:prune_binding` - (since v1.14.2) prune binding to keep only + variables read or written by the evaluated code. Note that + variables used by modules are always pruned, even if later used + by the modules. You can submit to the `:on_module` tracer event + and access the variables used by the module from its environment. + + """ + @doc since: "1.14.0" + def eval_quoted_with_env(quoted, binding, %Macro.Env{} = env, opts \\ []) + when is_list(binding) do + eval_verify(:eval_quoted, [quoted, binding, env, opts]) + end + + @doc ~S""" + Converts the given string to its quoted form. + + Returns `{:ok, quoted_form}` if it succeeds, + `{:error, {meta, message_info, token}}` otherwise. + + ## Options + + * `:file` - the filename to be reported in case of parsing errors. + Defaults to `"nofile"`. + + * `:line` - the starting line of the string being parsed. + Defaults to 1. + + * `:column` - (since v1.11.0) the starting column of the string being parsed. + Defaults to 1. + + * `:columns` - when `true`, attach a `:column` key to the quoted + metadata. Defaults to `false`. + + * `:unescape` (since v1.10.0) - when `false`, preserves escaped sequences. + For example, `"null byte\\t\\x00"` will be kept as is instead of being + converted to a bitstring literal. Note if you set this option to false, the + resulting AST is no longer valid, but it can be useful to analyze/transform + source code, typically in in combination with `quoted_to_algebra/2`. + Defaults to `true`. + + * `:existing_atoms_only` - when `true`, raises an error + when non-existing atoms are found by the tokenizer. + Defaults to `false`. + + * `:token_metadata` (since v1.10.0) - when `true`, includes token-related + metadata in the expression AST, such as metadata for `do` and `end` + tokens, for closing tokens, end of expressions, as well as delimiters + for sigils. See `t:Macro.metadata/0`. Defaults to `false`. + + * `:literal_encoder` (since v1.10.0) - how to encode literals in the AST. + It must be a function that receives two arguments, the literal and its + metadata, and it must return `{:ok, ast :: Macro.t}` or + `{:error, reason :: binary}`. If you return anything than the literal + itself as the `term`, then the AST is no longer valid. This option + may still useful for textual analysis of the source code. + + * `:static_atoms_encoder` - the static atom encoder function, see + "The `:static_atoms_encoder` function" section below. Note this + option overrides the `:existing_atoms_only` behaviour for static + atoms but `:existing_atoms_only` is still used for dynamic atoms, + such as atoms with interpolations. + + * `:warn_on_unnecessary_quotes` - when `false`, does not warn + when atoms, keywords or calls have unnecessary quotes on + them. Defaults to `true`. + + ## `Macro.to_string/2` + + The opposite of converting a string to its quoted form is + `Macro.to_string/2`, which converts a quoted form to a string/binary + representation. + + ## The `:static_atoms_encoder` function + + When `static_atoms_encoder: &my_encoder/2` is passed as an argument, + `my_encoder/2` is called every time the tokenizer needs to create a + "static" atom. Static atoms are atoms in the AST that function as + aliases, remote calls, local calls, variable names, regular atoms + and keyword lists. + + The encoder function will receive the atom name (as a binary) and a + keyword list with the current file, line and column. It must return + `{:ok, token :: term} | {:error, reason :: binary}`. + + The encoder function is supposed to create an atom from the given + string. To produce a valid AST, it is required to return `{:ok, term}`, + where `term` is an atom. It is possible to return something other than an atom, + however, in that case the AST is no longer "valid" in that it cannot + be used to compile or evaluate Elixir code. A use case for this is + if you want to use the Elixir parser in a user-facing situation, but + you don't want to exhaust the atom table. + + The atom encoder is not called for *all* atoms that are present in + the AST. It won't be invoked for the following atoms: + + * operators (`:+`, `:-`, and so on) + + * syntax keywords (`fn`, `do`, `else`, and so on) + + * atoms containing interpolation (`:"#{1 + 1} is two"`), as these + atoms are constructed at runtime. + + """ + @spec string_to_quoted(List.Chars.t(), keyword) :: + {:ok, Macro.t()} | {:error, {location :: keyword, binary | {binary, binary}, binary}} + def string_to_quoted(string, opts \\ []) when is_list(opts) do + file = Keyword.get(opts, :file, "nofile") + line = Keyword.get(opts, :line, 1) + column = Keyword.get(opts, :column, 1) + + case :future_elixir.string_to_tokens(to_charlist(string), line, column, file, opts) do + {:ok, tokens} -> + :future_elixir.tokens_to_quoted(tokens, file, opts) + + {:error, _error_msg} = error -> + error + end + end + + @doc """ + Converts the given string to its quoted form. + + It returns the AST if it succeeds, + raises an exception otherwise. The exception is a `TokenMissingError` + in case a token is missing (usually because the expression is incomplete), + `SyntaxError` otherwise. + + Check `string_to_quoted/2` for options information. + """ + @spec string_to_quoted!(List.Chars.t(), keyword) :: Macro.t() + def string_to_quoted!(string, opts \\ []) when is_list(opts) do + file = Keyword.get(opts, :file, "nofile") + line = Keyword.get(opts, :line, 1) + column = Keyword.get(opts, :column, 1) + :elixir.string_to_quoted!(to_charlist(string), line, column, file, opts) + end + + @doc """ + Converts the given string to its quoted form and a list of comments. + + This function is useful when performing textual changes to the source code, + while preserving information like comments and literals position. + + Returns `{:ok, quoted_form, comments}` if it succeeds, + `{:error, {line, error, token}}` otherwise. + + Comments are maps with the following fields: + + * `:line` - The line number the source code + + * `:text` - The full text of the comment, including the leading `#` + + * `:previous_eol_count` - How many end of lines there are between the comment and the previous AST node or comment + + * `:next_eol_count` - How many end of lines there are between the comment and the next AST node or comment + + Check `string_to_quoted/2` for options information. + + ## Examples + + iex> Code.string_to_quoted_with_comments("\"" + ...> :foo + ...> + ...> # Hello, world! + ...> + ...> + ...> # Some more comments! + ...> "\"") + {:ok, :foo, [ + %{line: 3, column: 1, previous_eol_count: 2, next_eol_count: 3, text: "\# Hello, world!"}, + %{line: 6, column: 1, previous_eol_count: 3, next_eol_count: 1, text: "\# Some more comments!"}, + ]} + + iex> Code.string_to_quoted_with_comments(":foo # :bar") + {:ok, :foo, [ + %{line: 1, column: 6, previous_eol_count: 0, next_eol_count: 0, text: "\# :bar"} + ]} + + """ + @doc since: "1.13.0" + @spec string_to_quoted_with_comments(List.Chars.t(), keyword) :: + {:ok, Macro.t(), list(map())} | {:error, {location :: keyword, term, term}} + def string_to_quoted_with_comments(string, opts \\ []) when is_list(opts) do + charlist = to_charlist(string) + file = Keyword.get(opts, :file, "nofile") + line = Keyword.get(opts, :line, 1) + column = Keyword.get(opts, :column, 1) + + Process.put(:code_formatter_comments, []) + opts = [preserve_comments: &preserve_comments/5] ++ opts + + with {:ok, tokens} <- :future_elixir.string_to_tokens(charlist, line, column, file, opts), + {:ok, forms} <- :future_elixir.tokens_to_quoted(tokens, file, opts) do + comments = Enum.reverse(Process.get(:code_formatter_comments)) + {:ok, forms, comments} + end + after + Process.delete(:code_formatter_comments) + end + + @doc """ + Converts the given string to its quoted form and a list of comments. + + Returns the AST and a list of comments if it succeeds, raises an exception + otherwise. The exception is a `TokenMissingError` in case a token is missing + (usually because the expression is incomplete), `SyntaxError` otherwise. + + Check `string_to_quoted/2` for options information. + """ + @doc since: "1.13.0" + @spec string_to_quoted_with_comments!(List.Chars.t(), keyword) :: {Macro.t(), list(map())} + def string_to_quoted_with_comments!(string, opts \\ []) do + charlist = to_charlist(string) + + case string_to_quoted_with_comments(charlist, opts) do + {:ok, forms, comments} -> + {forms, comments} + + {:error, {location, error, token}} -> + :future_elixir_errors.parse_error( + location, + Keyword.get(opts, :file, "nofile"), + error, + token, + {charlist, Keyword.get(opts, :line, 1), Keyword.get(opts, :column, 1)} + ) + end + end + + defp preserve_comments(line, column, tokens, comment, rest) do + comments = Process.get(:code_formatter_comments) + + comment = %{ + line: line, + column: column, + previous_eol_count: previous_eol_count(tokens), + next_eol_count: next_eol_count(rest, 0), + text: List.to_string(comment) + } + + Process.put(:code_formatter_comments, [comment | comments]) + end + + defp next_eol_count([?\s | rest], count), do: next_eol_count(rest, count) + defp next_eol_count([?\t | rest], count), do: next_eol_count(rest, count) + defp next_eol_count([?\n | rest], count), do: next_eol_count(rest, count + 1) + defp next_eol_count([?\r, ?\n | rest], count), do: next_eol_count(rest, count + 1) + defp next_eol_count(_, count), do: count + + defp previous_eol_count([{token, {_, _, count}} | _]) + when token in [:eol, :",", :";"] and count > 0 do + count + end + + defp previous_eol_count([]), do: 1 + defp previous_eol_count(_), do: 0 + + @doc ~S""" + Converts a quoted expression to an algebra document using Elixir's formatter rules. + + The algebra document can be converted into a string by calling: + + doc + |> Inspect.Algebra.format(:infinity) + |> IO.iodata_to_binary() + + For a high-level function that does the same, see `Macro.to_string/1`. + + ## Formatting considerations + + The Elixir AST does not contain metadata for literals like strings, lists, or + tuples with two elements, which means that the produced algebra document will + not respect all of the user preferences and comments may be misplaced. + To get better results, you can use the `:token_metadata`, `:unescape` and + `:literal_encoder` options to `string_to_quoted/2` to provide additional + information to the formatter: + + [ + literal_encoder: &{:ok, {:__block__, &2, [&1]}}, + token_metadata: true, + unescape: false + ] + + This will produce an AST that contains information such as `do` blocks start + and end lines or sigil delimiters, and by wrapping literals in blocks they can + now hold metadata like line number, string delimiter and escaped sequences, or + integer formatting (such as `0x2a` instead of `47`). However, **note this AST is + not valid**. If you evaluate it, it won't have the same semantics as the regular + Elixir AST due to the `:unescape` and `:literal_encoder` options. However, + those options are useful if you're doing source code manipulation, where it's + important to preserve user choices and comments placing. + + ## Options + + * `:comments` - the list of comments associated with the quoted expression. + Defaults to `[]`. It is recommended that both `:token_metadata` and + `:literal_encoder` options are given to `string_to_quoted_with_comments/2` + in order to get proper placement for comments + + * `:escape` - when `true`, escaped sequences like `\n` will be escaped into + `\\n`. If the `:unescape` option was set to `false` when using + `string_to_quoted/2`, setting this option to `false` will prevent it from + escaping the sequences twice. Defaults to `true`. + + * `:locals_without_parens` - a keyword list of name and arity + pairs that should be kept without parens whenever possible. + The arity may be the atom `:*`, which implies all arities of + that name. The formatter already includes a list of functions + and this option augments this list. + + * `:syntax_colors` - a keyword list of colors the output is colorized. + See `Inspect.Opts` for more information. + """ + @doc since: "1.13.0" + @spec quoted_to_algebra(Macro.t(), keyword) :: Inspect.Algebra.t() + def quoted_to_algebra(quoted, opts \\ []) do + quoted + |> Code.Normalizer.normalize(opts) + |> Code.Formatter.to_algebra(opts) + end + + @doc """ + Evaluates the given file. + + Accepts `relative_to` as an argument to tell where the file is located. + + While `require_file/2` and `compile_file/2` return the loaded modules and their + bytecode, `eval_file/2` simply evaluates the file contents and returns the + evaluation result and its binding (exactly the same return value as `eval_string/3`). + """ + @spec eval_file(binary, nil | binary) :: {term, binding} + def eval_file(file, relative_to \\ nil) when is_binary(file) do + {charlist, file} = find_file!(file, relative_to) + eval_string(charlist, [], file: file, line: 1) + end + + @deprecated "Use Code.require_file/2 or Code.compile_file/2 instead" + @doc false + def load_file(file, relative_to \\ nil) when is_binary(file) do + {charlist, file} = find_file!(file, relative_to) + :elixir_code_server.call({:acquire, file}) + + loaded = + Module.ParallelChecker.verify(fn -> + :elixir_compiler.string(charlist, file, fn _, _ -> :ok end) + end) + + :elixir_code_server.cast({:required, file}) + loaded + end + + @doc """ + Requires the given `file`. + + Accepts `relative_to` as an argument to tell where the file is located. + If the file was already required, `require_file/2` doesn't do anything and + returns `nil`. + + Note that if `require_file/2` is invoked by different processes concurrently, + the first process to invoke `require_file/2` acquires a lock and the remaining + ones will block until the file is available. This means that if `require_file/2` + is called more than once with a given file, that file will be compiled only once. + The first process to call `require_file/2` will get the list of loaded modules, + others will get `nil`. The list of required files is managed per Erlang VM node. + + See `compile_file/2` if you would like to compile a file without tracking its + filenames. Finally, if you would like to get the result of evaluating a file rather + than the modules defined in it, see `eval_file/2`. + + ## Examples + + If the file has not been required, it returns the list of modules: + + modules = Code.require_file("eex_test.exs", "../eex/test") + List.first(modules) + #=> {EExTest.Compiled, <<70, 79, 82, 49, ...>>} + + If the file has been required, it returns `nil`: + + Code.require_file("eex_test.exs", "../eex/test") + #=> nil + + """ + @spec require_file(binary, nil | binary) :: [{module, binary}] | nil + def require_file(file, relative_to \\ nil) when is_binary(file) do + {charlist, file} = find_file!(file, relative_to) + + case :elixir_code_server.call({:acquire, file}) do + :required -> + nil + + :proceed -> + loaded = + Module.ParallelChecker.verify(fn -> + :elixir_compiler.string(charlist, file, fn _, _ -> :ok end) + end) + + :elixir_code_server.cast({:required, file}) + loaded + end + end + + @doc """ + Gets all compilation options from the code server. + + To get individual options, see `get_compiler_option/1`. + For a description of all options, see `put_compiler_option/2`. + + ## Examples + + Code.compiler_options() + #=> %{debug_info: true, docs: true, ...} + + """ + @spec compiler_options :: map + def compiler_options do + for key <- @available_compiler_options, into: %{} do + {key, :elixir_config.get(key)} + end + end + + @doc """ + Stores all given compilation options. + + Changing the compilation options affect all processes + running in a given Erlang VM node. To store individual + options and for a description of all options, see + `put_compiler_option/2`. + + Returns a map with previous values. + + ## Examples + + Code.compiler_options(warnings_as_errors: true) + #=> %{warnings_as_errors: false} + + """ + @spec compiler_options(Enumerable.t({atom, term})) :: %{optional(atom) => term} + def compiler_options(opts) do + for {key, value} <- opts, into: %{} do + previous = get_compiler_option(key) + put_compiler_option(key, value) + {key, previous} + end + end + + @doc """ + Returns the value of a given compiler option. + + For a description of all options, see `put_compiler_option/2`. + + ## Examples + + Code.get_compiler_option(:debug_info) + #=> true + + """ + @doc since: "1.10.0" + @spec get_compiler_option(atom) :: term + def get_compiler_option(key) when key in @available_compiler_options do + :elixir_config.get(key) + end + + @doc """ + Returns a list with all available compiler options. + + For a description of all options, see `put_compiler_option/2`. + + ## Examples + + Code.available_compiler_options() + #=> [:docs, :debug_info, ...] + + """ + @spec available_compiler_options() :: [atom] + def available_compiler_options do + @available_compiler_options + end + + @doc """ + Stores a compilation option. + + Changing the compilation options affect all processes running in a + given Erlang VM node. + + Available options are: + + * `:docs` - when `true`, retains documentation in the compiled module. + Defaults to `true`. + + * `:debug_info` - when `true`, retains debug information in the compiled + module. Defaults to `true`. + This enables static analysis tools as it allows developers to + partially reconstruct the original source code. Therefore, disabling + `:debug_info` is not recommended as it removes the ability of the + Elixir compiler and other tools to provide feedback. If you want to + remove the `:debug_info` while deploying, tools like `mix release` + already do such by default. + Additionally, `mix test` disables it via the `:test_elixirc_options` + project configuration option. + This option can also be overridden per module using the `@compile` directive. + + * `:ignore_already_consolidated` (since v1.10.0) - when `true`, does not warn + when a protocol has already been consolidated and a new implementation is added. + Defaults to `false`. + + * `:ignore_module_conflict` - when `true`, does not warn when a module has + already been defined. Defaults to `false`. + + * `:relative_paths` - when `true`, uses relative paths in quoted nodes, + warnings, and errors generated by the compiler. Note disabling this option + won't affect runtime warnings and errors. Defaults to `true`. + + * `:warnings_as_errors` - causes compilation to fail when warnings are + generated. Defaults to `false`. + + * `:no_warn_undefined` (since v1.10.0) - list of modules and `{Mod, fun, arity}` + tuples that will not emit warnings that the module or function does not exist + at compilation time. Pass atom `:all` to skip warning for all undefined + functions. This can be useful when doing dynamic compilation. Defaults to `[]`. + + * `:tracers` (since v1.10.0) - a list of tracers (modules) to be used during + compilation. See the module docs for more information. Defaults to `[]`. + + * `:parser_options` (since v1.10.0) - a keyword list of options to be given + to the parser when compiling files. It accepts the same options as + `string_to_quoted/2` (except by the options that change the AST itself). + This can be used in combination with the tracer to retrieve localized + information about events happening during compilation. Defaults to `[]`. + This option only affects code compilation functions, such as `compile_string/2` + and `compile_file/2` but not `string_to_quoted/2` and friends, as the + latter is used for other purposes beyond compilation. + + * `:on_undefined_variable` (since v1.15.0) - either `:raise` or `:warn`. + When `:raise` (the default), undefined variables will trigger a compilation + error. You may be set it to `:warn` if you want undefined variables to + emit a warning and expand as to a local call to the zero-arity function + of the same name (for example, `node` would be expanded as `node()`). + This `:warn` behaviour only exists for compatibility reasons when working + with old dependencies. + + It always returns `:ok`. Raises an error for invalid options. + + ## Examples + + Code.put_compiler_option(:debug_info, true) + #=> :ok + + """ + @doc since: "1.10.0" + @spec put_compiler_option(atom, term) :: :ok + def put_compiler_option(key, value) when key in @boolean_compiler_options do + if not is_boolean(value) do + raise "compiler option #{inspect(key)} should be a boolean, got: #{inspect(value)}" + end + + :elixir_config.put(key, value) + :ok + end + + def put_compiler_option(:no_warn_undefined, value) do + if value != :all and not is_list(value) do + raise "compiler option :no_warn_undefined should be a list or the atom :all, " <> + "got: #{inspect(value)}" + end + + :elixir_config.put(:no_warn_undefined, value) + :ok + end + + def put_compiler_option(key, value) when key in @list_compiler_options do + if not is_list(value) do + raise "compiler option #{inspect(key)} should be a list, got: #{inspect(value)}" + end + + if key == :parser_options and not Keyword.keyword?(value) do + raise "compiler option #{inspect(key)} should be a keyword list, " <> + "got: #{inspect(value)}" + end + + if key == :tracers and not Enum.all?(value, &is_atom/1) do + raise "compiler option #{inspect(key)} should be a list of modules, " <> + "got: #{inspect(value)}" + end + + :elixir_config.put(key, value) + :ok + end + + # TODO: Make this option have no effect on Elixir v2.0 + def put_compiler_option(:on_undefined_variable, value) when value in [:raise, :warn] do + :elixir_config.put(:on_undefined_variable, value) + :ok + end + + def put_compiler_option(key, _value) do + raise "unknown compiler option: #{inspect(key)}" + end + + @doc """ + Purge compiler modules. + + The compiler utilizes temporary modules to compile code. For example, + `elixir_compiler_1`, `elixir_compiler_2`, and so on. In case the compiled code + stores references to anonymous functions or similar, the Elixir compiler + may be unable to reclaim those modules, keeping an unnecessary amount of + code in memory and eventually leading to modules such as `elixir_compiler_12345`. + + This function purges all modules currently kept by the compiler, allowing + old compiler module names to be reused. If there are any processes running + any code from such modules, they will be terminated too. + + This function is only meant to be called if you have a long running node + that is constantly evaluating code. + + It returns `{:ok, number_of_modules_purged}`. + """ + @doc since: "1.7.0" + @spec purge_compiler_modules() :: {:ok, non_neg_integer()} + def purge_compiler_modules() do + :elixir_code_server.call(:purge_compiler_modules) + end + + @doc """ + Compiles the given string. + + Returns a list of tuples where the first element is the module name + and the second one is its bytecode (as a binary). A `file` can be + given as second argument which will be used for reporting warnings + and errors. + + **Warning**: `string` can be any Elixir code and code can be executed with + the same privileges as the Erlang VM: this means that such code could + compromise the machine (for example by executing system commands). + Don't use `compile_string/2` with untrusted input (such as strings coming + from the network). + """ + @spec compile_string(List.Chars.t(), binary) :: [{module, binary}] + def compile_string(string, file \\ "nofile") when is_binary(file) do + Module.ParallelChecker.verify(fn -> + :elixir_compiler.string(to_charlist(string), file, fn _, _ -> :ok end) + end) + end + + @doc """ + Compiles the quoted expression. + + Returns a list of tuples where the first element is the module name and + the second one is its bytecode (as a binary). A `file` can be + given as second argument which will be used for reporting warnings + and errors. + """ + @spec compile_quoted(Macro.t(), binary) :: [{module, binary}] + def compile_quoted(quoted, file \\ "nofile") when is_binary(file) do + Module.ParallelChecker.verify(fn -> + :elixir_compiler.quoted(quoted, file, fn _, _ -> :ok end) + end) + end + + @doc """ + Compiles the given file. + + Accepts `relative_to` as an argument to tell where the file is located. + + Returns a list of tuples where the first element is the module name and + the second one is its bytecode (as a binary). Opposite to `require_file/2`, + it does not track the filename of the compiled file. + + If you would like to get the result of evaluating file rather than the + modules defined in it, see `eval_file/2`. + + For compiling many files concurrently, see `Kernel.ParallelCompiler.compile/2`. + """ + @doc since: "1.7.0" + @spec compile_file(binary, nil | binary) :: [{module, binary}] + def compile_file(file, relative_to \\ nil) when is_binary(file) do + Module.ParallelChecker.verify(fn -> + {charlist, file} = find_file!(file, relative_to) + :elixir_compiler.string(charlist, file, fn _, _ -> :ok end) + end) + end + + @doc """ + Ensures the given module is loaded. + + If the module is already loaded, this works as no-op. If the module + was not yet loaded, it tries to load it. + + If it succeeds in loading the module, it returns `{:module, module}`. + If not, returns `{:error, reason}` with the error reason. + + See the module documentation for more information on code loading. + + ## Examples + + iex> Code.ensure_loaded(Atom) + {:module, Atom} + + iex> Code.ensure_loaded(DoesNotExist) + {:error, :nofile} + + """ + @spec ensure_loaded(module) :: + {:module, module} | {:error, :embedded | :badfile | :nofile | :on_load_failure} + def ensure_loaded(module) when is_atom(module) do + :code.ensure_loaded(module) + end + + @doc """ + Ensures the given module is loaded. + + Similar to `ensure_loaded/1`, but returns `true` if the module + is already loaded or was successfully loaded. Returns `false` + otherwise. + + ## Examples + + iex> Code.ensure_loaded?(String) + true + + """ + @spec ensure_loaded?(module) :: boolean + def ensure_loaded?(module) when is_atom(module) do + match?({:module, ^module}, ensure_loaded(module)) + end + + @doc """ + Same as `ensure_loaded/1` but raises if the module cannot be loaded. + """ + @doc since: "1.12.0" + @spec ensure_loaded!(module) :: module + def ensure_loaded!(module) do + case ensure_loaded(module) do + {:module, module} -> + module + + {:error, reason} -> + raise ArgumentError, + "could not load module #{inspect(module)} due to reason #{inspect(reason)}" + end + end + + @doc """ + Ensures the given modules are loaded. + + Similar to `ensure_loaded/1`, but accepts a list of modules instead of a single + module, and loads all of them. + + If all modules load successfully, returns `:ok`. Otherwise, returns `{:error, errors}` + where `errors` is a list of tuples made of the module and the reason it failed to load. + + ## Examples + + iex> Code.ensure_all_loaded([Atom, String]) + :ok + + iex> Code.ensure_all_loaded([Atom, DoesNotExist]) + {:error, [{DoesNotExist, :nofile}]} + + """ + @doc since: "1.15.0" + @spec ensure_all_loaded([module]) :: :ok | {:error, [{module, reason}]} + when reason: :badfile | :nofile | :on_load_failure + def ensure_all_loaded(modules) when is_list(modules) do + :code.ensure_modules_loaded(modules) + end + + @doc """ + Same as `ensure_all_loaded/1` but raises if any of the modules cannot be loaded. + """ + @doc since: "1.15.0" + @spec ensure_all_loaded!([module]) :: :ok + def ensure_all_loaded!(modules) do + case ensure_all_loaded(modules) do + :ok -> + :ok + + {:error, errors} -> + formatted_errors = + errors + |> Enum.sort() + |> Enum.map_join("\n", fn {module, reason} -> + " * #{inspect(module)} due to reason #{inspect(reason)}" + end) + + raise ArgumentError, "could not load the following modules:\n\n" <> formatted_errors + end + end + + @doc """ + Similar to `ensure_compiled!/1` but indicates you can continue without said module. + + While `ensure_compiled!/1` indicates to the Elixir compiler you can + only continue when said module is available, this function indicates + you may continue compilation without said module. + + If it succeeds in loading the module, it returns `{:module, module}`. + If not, returns `{:error, reason}` with the error reason. + If the module being checked is currently in a compiler deadlock, + this function returns `{:error, :unavailable}`. Unavailable doesn't + necessarily mean the module doesn't exist, just that it is not currently + available, but it (or may not) become available in the future. + + Therefore, if you can only continue if the module is available, use + `ensure_compiled!/1` instead. In particular, do not do this: + + case Code.ensure_compiled(module) do + {:module, _} -> module + {:error, _} -> raise ... + end + + See the module documentation for more information on code loading. + """ + @spec ensure_compiled(module) :: + {:module, module} + | {:error, :embedded | :badfile | :nofile | :on_load_failure | :unavailable} + def ensure_compiled(module) when is_atom(module) do + ensure_compiled(module, :soft) + end + + @doc """ + Ensures the given module is compiled and loaded. + + If the module is already loaded, it works as no-op. If the module was + not compiled yet, `ensure_compiled!/1` halts the compilation of the caller + until the module given to `ensure_compiled!/1` becomes available or + all files for the current project have been compiled. If compilation + finishes and the module is not available or is in a deadlock, an error + is raised. + + Given this function halts compilation, use it carefully. In particular, + avoid using it to guess which modules are in the system. Overuse of this + function can also lead to deadlocks, where two modules check at the same time + if the other is compiled. This returns a specific unavailable error code, + where we cannot successfully verify a module is available or not. + + See the module documentation for more information on code loading. + """ + @doc since: "1.12.0" + @spec ensure_compiled!(module) :: module + def ensure_compiled!(module) do + case ensure_compiled(module, :hard) do + {:module, module} -> + module + + {:error, reason} -> + raise ArgumentError, + "could not load module #{inspect(module)} due to reason #{inspect(reason)}" + end + end + + defp ensure_compiled(module, mode) do + case :code.ensure_loaded(module) do + {:error, :nofile} = error -> + if can_await_module_compilation?() do + case Kernel.ErrorHandler.ensure_compiled(module, :module, mode) do + :found -> {:module, module} + :deadlock -> {:error, :unavailable} + :not_found -> {:error, :nofile} + end + else + error + end + + other -> + other + end + end + + @doc """ + Returns `true` if the module is loaded. + + This function doesn't attempt to load the module. For such behaviour, + `ensure_loaded?/1` can be used. + + ## Examples + + iex> Code.loaded?(Atom) + true + + iex> Code.loaded?(NotYetLoaded) + false + + """ + @doc since: "1.15.0" + @spec loaded?(module) :: boolean + def loaded?(module) do + :erlang.module_loaded(module) + end + + @doc """ + Returns true if the current process can await for module compilation. + + When compiling Elixir code via `Kernel.ParallelCompiler`, which is + used by Mix and `elixirc`, calling a module that has not yet been + compiled will block the caller until the module becomes available. + Executing Elixir scripts, such as passing a filename to `elixir`, + does not await. + """ + @doc since: "1.11.0" + @spec can_await_module_compilation? :: boolean + def can_await_module_compilation? do + :erlang.process_info(self(), :error_handler) == {:error_handler, Kernel.ErrorHandler} + end + + @doc false + @deprecated "Use Code.ensure_compiled/1 instead (see the proper disclaimers in its docs)" + def ensure_compiled?(module) when is_atom(module) do + match?({:module, ^module}, ensure_compiled(module)) + end + + @doc ~S""" + Returns the docs for the given module or path to `.beam` file. + + When given a module name, it finds its BEAM code and reads the docs from it. + + When given a path to a `.beam` file, it will load the docs directly from that + file. + + It returns the term stored in the documentation chunk in the format defined by + [EEP 48](https://www.erlang.org/eeps/eep-0048.html) or `{:error, reason}` if + the chunk is not available. + + ## Examples + + # Module documentation of an existing module + iex> {:docs_v1, _, :elixir, _, %{"en" => module_doc}, _, _} = Code.fetch_docs(Atom) + iex> module_doc |> String.split("\n") |> Enum.at(0) + "Atoms are constants whose values are their own name." + + # A module that doesn't exist + iex> Code.fetch_docs(ModuleNotGood) + {:error, :module_not_found} + + """ + @doc since: "1.7.0" + @spec fetch_docs(module | String.t()) :: + {:docs_v1, annotation, beam_language, format, module_doc :: doc_content, metadata, + docs :: [doc_element]} + | {:error, :module_not_found | :chunk_not_found | {:invalid_chunk, binary}} + when annotation: :erl_anno.anno(), + beam_language: :elixir | :erlang | atom(), + doc_content: %{optional(binary) => binary} | :none | :hidden, + doc_element: + {{kind :: atom, function_name :: atom, arity}, annotation, signature, doc_content, + metadata}, + format: binary, + signature: [binary], + metadata: map + def fetch_docs(module_or_path) + + def fetch_docs(module) when is_atom(module) do + case get_beam_and_path(module) do + {bin, beam_path} -> + case fetch_docs_from_beam(bin) do + {:error, :chunk_not_found} -> + app_root = Path.expand(Path.join(["..", ".."]), beam_path) + path = Path.join([app_root, "doc", "chunks", "#{module}.chunk"]) + fetch_docs_from_chunk(path) + + other -> + other + end + + :error -> + case :code.is_loaded(module) do + {:file, :preloaded} -> + # The ERTS directory is not necessarily included in releases + # unless it is listed as an extra application. + case :code.lib_dir(:erts) do + path when is_list(path) -> + path = Path.join([path, "doc", "chunks", "#{module}.chunk"]) + fetch_docs_from_chunk(path) + + {:error, _} -> + {:error, :chunk_not_found} + end + + _ -> + {:error, :module_not_found} + end + end + end + + def fetch_docs(path) when is_binary(path) do + fetch_docs_from_beam(String.to_charlist(path)) + end + + defp get_beam_and_path(module) do + with {^module, beam, filename} <- :code.get_object_code(module), + {:ok, ^module} <- beam |> :beam_lib.info() |> Keyword.fetch(:module) do + {beam, filename} + else + _ -> :error + end + end + + @docs_chunk [?D, ?o, ?c, ?s] + + defp fetch_docs_from_beam(bin_or_path) do + case :beam_lib.chunks(bin_or_path, [@docs_chunk]) do + {:ok, {_module, [{@docs_chunk, bin}]}} -> + load_docs_chunk(bin) + + {:error, :beam_lib, {:missing_chunk, _, @docs_chunk}} -> + {:error, :chunk_not_found} + + {:error, :beam_lib, {:file_error, _, :enoent}} -> + {:error, :module_not_found} + end + end + + defp fetch_docs_from_chunk(path) do + case File.read(path) do + {:ok, bin} -> + load_docs_chunk(bin) + + {:error, _} -> + {:error, :chunk_not_found} + end + end + + defp load_docs_chunk(bin) do + :erlang.binary_to_term(bin) + rescue + _ -> + {:error, {:invalid_chunk, bin}} + end + + @doc false + @deprecated "Code.get_docs/2 always returns nil as its outdated documentation is no longer stored on BEAM files. Use Code.fetch_docs/1 instead" + def get_docs(_module, _kind) do + nil + end + + ## Helpers + + # Finds the file given the relative_to path. + # + # If the file is found, returns its path in binary, fails otherwise. + defp find_file!(file, relative_to) do + file = + if relative_to do + Path.expand(file, relative_to) + else + Path.expand(file) + end + + case File.read(file) do + {:ok, bin} -> {String.to_charlist(bin), file} + {:error, reason} -> raise Code.LoadError, file: file, reason: reason + end + end +end diff --git a/forge/lib/future/code/fragment.ex b/forge/lib/future/code/fragment.ex new file mode 100644 index 00000000..2645d135 --- /dev/null +++ b/forge/lib/future/code/fragment.ex @@ -0,0 +1,1132 @@ +# Copied from https://raw.githubusercontent.com/elixir-lang/elixir/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/lib/code/fragment.ex +defmodule Future.Code.Fragment do + alias Future.Code, as: Code + + @moduledoc """ + This module provides conveniences for analyzing fragments of + textual code and extract available information whenever possible. + + This module should be considered experimental. + """ + + @type position :: {line :: pos_integer(), column :: pos_integer()} + + @doc """ + Receives a string and returns the cursor context. + + This function receives a string with an Elixir code fragment, + representing a cursor position, and based on the string, it + provides contextual information about the latest token. + The return of this function can then be used to provide tips, + suggestions, and autocompletion functionality. + + This function performs its analyses on tokens. This means + it does not understand how constructs are nested within each + other. See the "Limitations" section below. + + Consider adding a catch-all clause when handling the return + type of this function as new cursor information may be added + in future releases. + + ## Examples + + iex> Code.Fragment.cursor_context("") + :expr + + iex> Code.Fragment.cursor_context("hello_wor") + {:local_or_var, ~c"hello_wor"} + + ## Return values + + * `{:alias, charlist}` - the context is an alias, potentially + a nested one, such as `Hello.Wor` or `HelloWor` + + * `{:alias, inside_alias, charlist}` - the context is an alias, potentially + a nested one, where `inside_alias` is an expression `{:module_attribute, charlist}` + or `{:local_or_var, charlist}` and `charlist` is a static part + Examples are `__MODULE__.Submodule` or `@hello.Submodule` + + * `{:dot, inside_dot, charlist}` - the context is a dot + where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`, + `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot` + itself. If a var is given, this may either be a remote call or a map + field access. Examples are `Hello.wor`, `:hello.wor`, `hello.wor`, + `Hello.nested.wor`, `hello.nested.wor`, and `@hello.world`. If `charlist` + is empty and `inside_dot` is an alias, then the autocompletion may either + be an alias or a remote call. + + * `{:dot_arity, inside_dot, charlist}` - the context is a dot arity + where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`, + `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot` + itself. If a var is given, it must be a remote arity. Examples are + `Hello.world/`, `:hello.world/`, `hello.world/2`, and `@hello.world/2` + + * `{:dot_call, inside_dot, charlist}` - the context is a dot + call. This means parentheses or space have been added after the expression. + where `inside_dot` is either a `{:var, charlist}`, `{:alias, charlist}`, + `{:module_attribute, charlist}`, `{:unquoted_atom, charlist}` or a `dot` + itself. If a var is given, it must be a remote call. Examples are + `Hello.world(`, `:hello.world(`, `Hello.world `, `hello.world(`, `hello.world `, + and `@hello.world(` + + * `:expr` - may be any expression. Autocompletion may suggest an alias, + local or var + + * `{:local_or_var, charlist}` - the context is a variable or a local + (import or local) call, such as `hello_wor` + + * `{:local_arity, charlist}` - the context is a local (import or local) + arity, such as `hello_world/` + + * `{:local_call, charlist}` - the context is a local (import or local) + call, such as `hello_world(` and `hello_world ` + + * `{:anonymous_call, inside_caller}` - the context is an anonymous + call, such as `fun.(` and `@fun.(`. + + * `{:module_attribute, charlist}` - the context is a module attribute, + such as `@hello_wor` + + * `{:operator, charlist}` - the context is an operator, such as `+` or + `==`. Note textual operators, such as `when` do not appear as operators + but rather as `:local_or_var`. `@` is never an `:operator` and always a + `:module_attribute` + + * `{:operator_arity, charlist}` - the context is an operator arity, which + is an operator followed by /, such as `+/`, `not/` or `when/` + + * `{:operator_call, charlist}` - the context is an operator call, which is + an operator followed by space, such as `left + `, `not ` or `x when ` + + * `:none` - no context possible + + * `{:sigil, charlist}` - the context is a sigil. It may be either the beginning + of a sigil, such as `~` or `~s`, or an operator starting with `~`, such as + `~>` and `~>>` + + * `{:struct, inside_struct}` - the context is a struct, such as `%`, `%UR` or `%URI`. + `inside_struct` can either be a `charlist` in case of a static alias or an + expression `{:alias, inside_alias, charlist}`, `{:module_attribute, charlist}`, + `{:local_or_var, charlist}`, `{:dot, inside_dot, charlist}` + + * `{:unquoted_atom, charlist}` - the context is an unquoted atom. This + can be any atom or an atom representing a module + + We recommend looking at the test suite of this function for a complete list + of examples and their return values. + + ## Limitations + + The analysis is based on the current token, by analysing the last line of + the input. For example, this code: + + iex> Code.Fragment.cursor_context("%URI{") + :expr + + returns `:expr`, which suggests any variable, local function or alias + could be used. However, given we are inside a struct, the best suggestion + would be a struct field. In such cases, you can use + `container_cursor_to_quoted`, which will return the container of the AST + the cursor is currently within. You can then analyse this AST to provide + completion of field names. + + As a consequence of its token-based implementation, this function considers + only the last line of the input. This means it will show suggestions inside + strings, heredocs, etc, which is intentional as it helps with doctests, + references, and more. + """ + @doc since: "1.13.0" + @spec cursor_context(List.Chars.t(), keyword()) :: + {:alias, charlist} + | {:alias, inside_alias, charlist} + | {:dot, inside_dot, charlist} + | {:dot_arity, inside_dot, charlist} + | {:dot_call, inside_dot, charlist} + | :expr + | {:local_or_var, charlist} + | {:local_arity, charlist} + | {:local_call, charlist} + | {:anonymous_call, inside_caller} + | {:module_attribute, charlist} + | {:operator, charlist} + | {:operator_arity, charlist} + | {:operator_call, charlist} + | :none + | {:sigil, charlist} + | {:struct, inside_struct} + | {:unquoted_atom, charlist} + when inside_dot: + {:alias, charlist} + | {:alias, inside_alias, charlist} + | {:dot, inside_dot, charlist} + | {:module_attribute, charlist} + | {:unquoted_atom, charlist} + | {:var, charlist} + | :expr, + inside_alias: + {:local_or_var, charlist} + | {:module_attribute, charlist}, + inside_struct: + charlist + | {:alias, inside_alias, charlist} + | {:local_or_var, charlist} + | {:module_attribute, charlist} + | {:dot, inside_dot, charlist}, + inside_caller: {:var, charlist} | {:module_attribute, charlist} + def cursor_context(fragment, opts \\ []) + + def cursor_context(fragment, opts) + when (is_binary(fragment) or is_list(fragment)) and is_list(opts) do + fragment + |> last_line() + |> :lists.reverse() + |> codepoint_cursor_context(opts) + |> elem(0) + end + + def cursor_context(other, opts) when is_list(opts) do + cursor_context(to_charlist(other), opts) + end + + @operators ~c"\\<>+-*/:=|&~^%!" + @starter_punctuation ~c",([{;" + @non_starter_punctuation ~c")]}\"'.$" + @space ~c"\t\s" + @trailing_identifier ~c"?!" + @tilde_op_prefix ~c"<=~" + + @non_identifier @trailing_identifier ++ + @operators ++ @starter_punctuation ++ @non_starter_punctuation ++ @space + + @textual_operators ~w(when not and or in)c + @keywords ~w(do end after else catch rescue fn true false nil)c + + defp codepoint_cursor_context(reverse, _opts) do + {stripped, spaces} = strip_spaces(reverse, 0) + + case stripped do + # It is empty + [] -> {:expr, 0} + # Structs + [?%, ?:, ?: | _] -> {{:struct, ~c""}, 1} + [?%, ?: | _] -> {{:unquoted_atom, ~c"%"}, 2} + [?% | _] -> {{:struct, ~c""}, 1} + # Token/AST only operators + [?>, ?= | rest] when rest == [] or hd(rest) != ?: -> {:expr, 0} + [?>, ?- | rest] when rest == [] or hd(rest) != ?: -> {:expr, 0} + # Two-digit containers + [?<, ?< | rest] when rest == [] or hd(rest) != ?< -> {:expr, 0} + # Ambiguity around : + [?: | rest] when rest == [] or hd(rest) != ?: -> unquoted_atom_or_expr(spaces) + # Dots + [?.] -> {:none, 0} + [?. | rest] when hd(rest) not in ~c".:" -> dot(rest, spaces + 1, ~c"") + # It is a local or remote call with parens + [?( | rest] -> call_to_cursor_context(strip_spaces(rest, spaces + 1)) + # A local arity definition + [?/ | rest] -> arity_to_cursor_context(strip_spaces(rest, spaces + 1)) + # Starting a new expression + [h | _] when h in @starter_punctuation -> {:expr, 0} + # It is a local or remote call without parens + rest when spaces > 0 -> call_to_cursor_context({rest, spaces}) + # It is an identifier + _ -> identifier_to_cursor_context(reverse, 0, false) + end + end + + defp strip_spaces([h | rest], count) when h in @space, do: strip_spaces(rest, count + 1) + defp strip_spaces(rest, count), do: {rest, count} + + defp unquoted_atom_or_expr(0), do: {{:unquoted_atom, ~c""}, 1} + defp unquoted_atom_or_expr(_), do: {:expr, 0} + + defp arity_to_cursor_context({reverse, spaces}) do + case identifier_to_cursor_context(reverse, spaces, true) do + {{:local_or_var, acc}, count} -> {{:local_arity, acc}, count} + {{:dot, base, acc}, count} -> {{:dot_arity, base, acc}, count} + {{:operator, acc}, count} -> {{:operator_arity, acc}, count} + {_, _} -> {:none, 0} + end + end + + defp call_to_cursor_context({reverse, spaces}) do + with [?. | rest] <- reverse, + {rest, spaces} = strip_spaces(rest, spaces), + [h | _] when h not in @non_identifier <- rest do + case identifier_to_cursor_context(rest, spaces, true) do + {{:local_or_var, acc}, count} -> {{:anonymous_call, {:var, acc}}, count + 1} + {{:module_attribute, _} = attr, count} -> {{:anonymous_call, attr}, count + 1} + {_, _} -> {:none, 0} + end + else + _ -> + case identifier_to_cursor_context(reverse, spaces, true) do + {{:local_or_var, acc}, count} -> {{:local_call, acc}, count} + {{:dot, base, acc}, count} -> {{:dot_call, base, acc}, count} + {{:operator, acc}, count} -> {{:operator_call, acc}, count} + {_, _} -> {:none, 0} + end + end + end + + defp identifier_to_cursor_context([?., ?., ?: | _], n, _), do: {{:unquoted_atom, ~c".."}, n + 3} + defp identifier_to_cursor_context([?., ?., ?. | _], n, _), do: {{:local_or_var, ~c"..."}, n + 3} + defp identifier_to_cursor_context([?., ?: | _], n, _), do: {{:unquoted_atom, ~c"."}, n + 2} + defp identifier_to_cursor_context([?., ?. | _], n, _), do: {{:operator, ~c".."}, n + 2} + + defp identifier_to_cursor_context(reverse, count, call_op?) do + case identifier(reverse, count) do + :none -> + {:none, 0} + + :operator -> + operator(reverse, count, [], call_op?) + + {:struct, {:module_attribute, acc}, count} -> + {{:struct, {:module_attribute, acc}}, count + 1} + + {:module_attribute, acc, count} -> + {{:module_attribute, acc}, count} + + {:sigil, acc, count} -> + {{:sigil, acc}, count} + + {:unquoted_atom, acc, count} -> + {{:unquoted_atom, acc}, count} + + {:alias, rest, acc, count} -> + case strip_spaces(rest, count) do + {~c"." ++ rest, count} when rest == [] or hd(rest) != ?. -> + nested_alias(rest, count + 1, acc) + + {~c"%" ++ _, count} -> + {{:struct, acc}, count + 1} + + _ -> + {{:alias, acc}, count} + end + + {:identifier, _, acc, count} when call_op? and acc in @textual_operators -> + {{:operator, acc}, count} + + {:identifier, [?%], acc, count} -> + case identifier_to_cursor_context(acc |> Enum.reverse(), count, true) do + {{:local_or_var, _} = identifier, _} -> {{:struct, identifier}, count + 1} + _ -> {:none, 0} + end + + {:identifier, rest, acc, count} -> + case strip_spaces(rest, count) do + {~c"." ++ rest, count} when rest == [] or hd(rest) != ?. -> + dot(rest, count + 1, acc) + + _ -> + {{:local_or_var, acc}, count} + end + end + end + + defp identifier([?? | rest], count), do: check_identifier(rest, count + 1, [??]) + defp identifier([?! | rest], count), do: check_identifier(rest, count + 1, [?!]) + defp identifier(rest, count), do: check_identifier(rest, count, []) + + defp check_identifier([h | t], count, acc) when h not in @non_identifier, + do: rest_identifier(t, count + 1, [h | acc]) + + defp check_identifier(_, _, _), do: :operator + + defp rest_identifier([h | rest], count, acc) when h not in @non_identifier do + rest_identifier(rest, count + 1, [h | acc]) + end + + defp rest_identifier(rest, count, [?@ | acc]) do + case tokenize_identifier(rest, count, acc) do + {:identifier, [?% | _rest], acc, count} -> {:struct, {:module_attribute, acc}, count} + {:identifier, _rest, acc, count} -> {:module_attribute, acc, count} + :none when acc == [] -> {:module_attribute, ~c"", count} + _ -> :none + end + end + + defp rest_identifier([?~ | rest], count, [letter]) + when (letter in ?A..?Z or letter in ?a..?z) and + (rest == [] or hd(rest) not in @tilde_op_prefix) do + {:sigil, [letter], count + 1} + end + + defp rest_identifier([?: | rest], count, acc) when rest == [] or hd(rest) != ?: do + case String.Tokenizer.tokenize(acc) do + {_, _, [], _, _, _} -> {:unquoted_atom, acc, count + 1} + _ -> :none + end + end + + defp rest_identifier([?? | _], _count, _acc) do + :none + end + + defp rest_identifier(rest, count, acc) do + tokenize_identifier(rest, count, acc) + end + + defp tokenize_identifier(rest, count, acc) do + case String.Tokenizer.tokenize(acc) do + # Not actually an atom cause rest is not a : + {:atom, _, _, _, _, _} -> + :none + + # Aliases must be ascii only + {:alias, _, _, _, false, _} -> + :none + + {kind, _, [], _, _, extra} -> + if :at in extra do + :none + else + {kind, rest, acc, count} + end + + _ -> + :none + end + end + + defp nested_alias(rest, count, acc) do + {rest, count} = strip_spaces(rest, count) + + case identifier_to_cursor_context(rest, count, true) do + {{:struct, prev}, count} when is_list(prev) -> + {{:struct, prev ++ ~c"." ++ acc}, count} + + {{:struct, {:alias, parent, prev}}, count} -> + {{:struct, {:alias, parent, prev ++ ~c"." ++ acc}}, count} + + {{:struct, prev}, count} -> + {{:struct, {:alias, prev, acc}}, count} + + {{:alias, prev}, count} -> + {{:alias, prev ++ ~c"." ++ acc}, count} + + {{:alias, parent, prev}, count} -> + {{:alias, parent, prev ++ ~c"." ++ acc}, count} + + {{:local_or_var, prev}, count} -> + {{:alias, {:local_or_var, prev}, acc}, count} + + {{:module_attribute, prev}, count} -> + {{:alias, {:module_attribute, prev}, acc}, count} + + _ -> + {:none, 0} + end + end + + defp dot(rest, count, acc) do + {rest, count} = strip_spaces(rest, count) + + case identifier_to_cursor_context(rest, count, true) do + {{:local_or_var, var}, count} -> + {{:dot, {:var, var}, acc}, count} + + {{:unquoted_atom, _} = prev, count} -> + {{:dot, prev, acc}, count} + + {{:alias, _} = prev, count} -> + {{:dot, prev, acc}, count} + + {{:alias, _, _} = prev, count} -> + {{:dot, prev, acc}, count} + + {{:struct, inner}, count} when is_list(inner) -> + {{:struct, {:dot, {:alias, inner}, acc}}, count} + + {{:struct, inner}, count} -> + {{:struct, {:dot, inner, acc}}, count} + + {{:dot, _, _} = prev, count} -> + {{:dot, prev, acc}, count} + + {{:module_attribute, _} = prev, count} -> + {{:dot, prev, acc}, count} + + {:expr, count} -> + {{:dot, :expr, acc}, count} + + {_, _} -> + {:none, 0} + end + end + + defp operator([h | rest], count, acc, call_op?) when h in @operators do + operator(rest, count + 1, [h | acc], call_op?) + end + + # If we are opening a sigil, ignore the operator. + defp operator([letter, ?~ | rest], _count, [op], _call_op?) + when op in ~c"<|/" and (letter in ?A..?Z or letter in ?a..?z) and + (rest == [] or hd(rest) not in @tilde_op_prefix) do + {:none, 0} + end + + defp operator(rest, count, ~c"~", call_op?) do + {rest, _} = strip_spaces(rest, count) + + if call_op? or match?([?. | rest] when rest == [] or hd(rest) != ?., rest) do + {:none, 0} + else + {{:sigil, ~c""}, count} + end + end + + defp operator([?) | rest], _, [], true) when hd(rest) != ?? do + {:expr, 0} + end + + defp operator(rest, count, acc, _call_op?) do + case :future_elixir_tokenizer.tokenize(acc, 1, 1, []) do + {:ok, _, _, _, [{:atom, _, _}], []} -> + {{:unquoted_atom, tl(acc)}, count} + + {:ok, _, _, _, [{_, _, op}], []} -> + {rest, dot_count} = strip_spaces(rest, count) + + cond do + Code.Identifier.unary_op(op) == :error and + Code.Identifier.binary_op(op) == :error -> + {:none, 0} + + match?([?. | rest] when rest == [] or hd(rest) != ?., rest) -> + dot(tl(rest), dot_count + 1, acc) + + true -> + {{:operator, acc}, count} + end + + _ -> + {:none, 0} + end + end + + @doc """ + Receives a string and returns the surround context. + + This function receives a string with an Elixir code fragment + and a `position`. It returns a map containing the beginning + and ending of the identifier alongside its context, or `:none` + if there is nothing with a known context. This is useful to + provide mouse-over and highlight functionality in editors. + + The difference between `cursor_context/2` and `surround_context/3` + is that the former assumes the expression in the code fragment + is incomplete. For example, `do` in `cursor_context/2` may be + a keyword or a variable or a local call, while `surround_context/3` + assumes the expression in the code fragment is complete, therefore + `do` would always be a keyword. + + The `position` contains both the `line` and `column`, both starting + with the index of 1. The column must precede the surrounding expression. + For example, the expression `foo`, will return something for the columns + 1, 2, and 3, but not 4: + + foo + ^ column 1 + + foo + ^ column 2 + + foo + ^ column 3 + + foo + ^ column 4 + + The returned map contains the column the expression starts and the + first column after the expression ends. + + Similar to `cursor_context/2`, this function is also token-based + and may not be accurate under all circumstances. See the + "Return values" and "Limitations" section under `cursor_context/2` + for more information. + + ## Examples + + iex> Code.Fragment.surround_context("foo", {1, 1}) + %{begin: {1, 1}, context: {:local_or_var, ~c"foo"}, end: {1, 4}} + + ## Differences to `cursor_context/2` + + Because `surround_context/3` attempts to capture complex expressions, + it has some differences to `cursor_context/2`: + + * `dot_call`/`dot_arity` and `operator_call`/`operator_arity` + are collapsed into `dot` and `operator` contexts respectively + as there aren't any meaningful distinctions between them + + * On the other hand, this function still makes a distinction between + `local_call`/`local_arity` and `local_or_var`, since the latter can + be a local or variable + + * `@` when not followed by any identifier is returned as `{:operator, '@'}` + (in contrast to `{:module_attribute, ''}` in `cursor_context/2` + + * This function never returns empty sigils `{:sigil, ''}` or empty structs + `{:struct, ''}` as context + + * This function returns keywords as `{:keyword, 'do'}` + + * This function never returns `:expr` + + We recommend looking at the test suite of this function for a complete list + of examples and their return values. + """ + @doc since: "1.13.0" + @spec surround_context(List.Chars.t(), position(), keyword()) :: + %{begin: position, end: position, context: context} | :none + when context: + {:alias, charlist} + | {:alias, inside_alias, charlist} + | {:dot, inside_dot, charlist} + | {:local_or_var, charlist} + | {:local_arity, charlist} + | {:local_call, charlist} + | {:module_attribute, charlist} + | {:operator, charlist} + | {:sigil, charlist} + | {:struct, inside_struct} + | {:unquoted_atom, charlist} + | {:keyword, charlist}, + inside_dot: + {:alias, charlist} + | {:alias, inside_alias, charlist} + | {:dot, inside_dot, charlist} + | {:module_attribute, charlist} + | {:unquoted_atom, charlist} + | {:var, charlist} + | :expr, + inside_alias: + {:local_or_var, charlist} + | {:module_attribute, charlist}, + inside_struct: + charlist + | {:alias, inside_alias, charlist} + | {:local_or_var, charlist} + | {:module_attribute, charlist} + | {:dot, inside_dot, charlist} + def surround_context(fragment, position, options \\ []) + + def surround_context(string, {line, column}, opts) + when (is_binary(string) or is_list(string)) and is_list(opts) do + {charlist, lines_before_lengths, lines_current_and_after_lengths} = + surround_line(string, line, column) + + prepended_columns = Enum.sum(lines_before_lengths) + + charlist + |> position_surround_context(line, column + prepended_columns, opts) + |> to_multiline_range( + prepended_columns, + lines_before_lengths, + lines_current_and_after_lengths + ) + end + + def surround_context(other, {_, _} = position, opts) do + surround_context(to_charlist(other), position, opts) + end + + defp position_surround_context(charlist, line, column, opts) + when is_integer(line) and line >= 1 and is_integer(column) and column >= 1 do + {reversed_pre, post} = string_reverse_at(charlist, column - 1, []) + {reversed_pre, post} = adjust_position(reversed_pre, post) + + case take_identifier(post, []) do + {_, [], _} -> + maybe_operator(reversed_pre, post, line, opts) + + {:identifier, reversed_post, rest} -> + {rest, _} = strip_spaces(rest, 0) + reversed = reversed_post ++ reversed_pre + + case codepoint_cursor_context(reversed, opts) do + {{:struct, acc}, offset} -> + build_surround({:struct, acc}, reversed, line, offset) + + {{:alias, acc}, offset} -> + build_surround({:alias, acc}, reversed, line, offset) + + {{:alias, parent, acc}, offset} -> + build_surround({:alias, parent, acc}, reversed, line, offset) + + {{:dot, _, [_ | _]} = dot, offset} -> + build_surround(dot, reversed, line, offset) + + {{:local_or_var, acc}, offset} when hd(rest) == ?( -> + build_surround({:local_call, acc}, reversed, line, offset) + + {{:local_or_var, acc}, offset} when hd(rest) == ?/ -> + build_surround({:local_arity, acc}, reversed, line, offset) + + {{:local_or_var, acc}, offset} when acc in @textual_operators -> + build_surround({:operator, acc}, reversed, line, offset) + + {{:local_or_var, acc}, offset} when acc in @keywords -> + build_surround({:keyword, acc}, reversed, line, offset) + + {{:local_or_var, acc}, offset} -> + build_surround({:local_or_var, acc}, reversed, line, offset) + + {{:module_attribute, ~c""}, offset} -> + build_surround({:operator, ~c"@"}, reversed, line, offset) + + {{:module_attribute, acc}, offset} -> + build_surround({:module_attribute, acc}, reversed, line, offset) + + {{:sigil, acc}, offset} -> + build_surround({:sigil, acc}, reversed, line, offset) + + {{:unquoted_atom, acc}, offset} -> + build_surround({:unquoted_atom, acc}, reversed, line, offset) + + _ -> + maybe_operator(reversed_pre, post, line, opts) + end + + {:alias, reversed_post, _rest} -> + reversed = reversed_post ++ reversed_pre + + case codepoint_cursor_context(reversed, opts) do + {{:alias, acc}, offset} -> + build_surround({:alias, acc}, reversed, line, offset) + + {{:alias, parent, acc}, offset} -> + build_surround({:alias, parent, acc}, reversed, line, offset) + + {{:struct, acc}, offset} -> + build_surround({:struct, acc}, reversed, line, offset) + + _ -> + :none + end + end + end + + defp maybe_operator(reversed_pre, post, line, opts) do + case take_operator(post, []) do + {[], _rest} -> + :none + + {reversed_post, rest} -> + reversed = reversed_post ++ reversed_pre + + case codepoint_cursor_context(reversed, opts) do + {{:operator, acc}, offset} -> + build_surround({:operator, acc}, reversed, line, offset) + + {{:sigil, ~c""}, offset} when hd(rest) in ?A..?Z or hd(rest) in ?a..?z -> + build_surround({:sigil, [hd(rest)]}, [hd(rest) | reversed], line, offset + 1) + + {{:dot, _, [_ | _]} = dot, offset} -> + build_surround(dot, reversed, line, offset) + + _ -> + :none + end + end + end + + defp build_surround(context, reversed, line, offset) do + {post, reversed_pre} = enum_reverse_at(reversed, offset, []) + pre = :lists.reverse(reversed_pre) + pre_length = :string.length(pre) + 1 + + %{ + context: context, + begin: {line, pre_length}, + end: {line, pre_length + :string.length(post)} + } + end + + defp take_identifier([h | t], acc) when h in @trailing_identifier, + do: {:identifier, [h | acc], t} + + defp take_identifier([h | t], acc) when h not in @non_identifier, + do: take_identifier(t, [h | acc]) + + defp take_identifier(rest, acc) do + with {[?. | t], _} <- strip_spaces(rest, 0), + {[h | _], _} when h in ?A..?Z <- strip_spaces(t, 0) do + take_alias(rest, acc) + else + _ -> {:identifier, acc, rest} + end + end + + defp take_alias([h | t], acc) when h in ?A..?Z or h in ?a..?z or h in ?0..?9 or h == ?_, + do: take_alias(t, [h | acc]) + + defp take_alias(rest, acc) do + with {[?. | t], acc} <- move_spaces(rest, acc), + {[h | t], acc} when h in ?A..?Z <- move_spaces(t, [?. | acc]) do + take_alias(t, [h | acc]) + else + _ -> {:alias, acc, rest} + end + end + + defp take_operator([h | t], acc) when h in @operators, do: take_operator(t, [h | acc]) + defp take_operator([h | t], acc) when h == ?., do: take_operator(t, [h | acc]) + defp take_operator(rest, acc), do: {acc, rest} + + # Unquoted atom handling + defp adjust_position(reversed_pre, [?: | post]) + when hd(post) != ?: and (reversed_pre == [] or hd(reversed_pre) != ?:) do + {[?: | reversed_pre], post} + end + + defp adjust_position(reversed_pre, [?% | post]) do + adjust_position([?% | reversed_pre], post) + end + + # Dot/struct handling + defp adjust_position(reversed_pre, post) do + case move_spaces(post, reversed_pre) do + # If we are between spaces and a dot, move past the dot + {[?. | post], reversed_pre} when hd(post) != ?. and hd(reversed_pre) != ?. -> + {post, reversed_pre} = move_spaces(post, [?. | reversed_pre]) + {reversed_pre, post} + + _ -> + case strip_spaces(reversed_pre, 0) do + # If there is a dot to our left, make sure to move to the first character + {[?. | rest], _} when rest == [] or hd(rest) not in ~c".:" -> + {post, reversed_pre} = move_spaces(post, reversed_pre) + {reversed_pre, post} + + # If there is a % to our left, make sure to move to the first character + {[?% | _], _} -> + case move_spaces(post, reversed_pre) do + {[h | _] = post, reversed_pre} when h in ?A..?Z -> + {reversed_pre, post} + + _ -> + {reversed_pre, post} + end + + _ -> + {reversed_pre, post} + end + end + end + + defp move_spaces([h | t], acc) when h in @space, do: move_spaces(t, [h | acc]) + defp move_spaces(t, acc), do: {t, acc} + + defp string_reverse_at(charlist, 0, acc), do: {acc, charlist} + + defp string_reverse_at(charlist, n, acc) do + case :unicode_util.gc(charlist) do + [gc | cont] when is_integer(gc) -> string_reverse_at(cont, n - 1, [gc | acc]) + [gc | cont] when is_list(gc) -> string_reverse_at(cont, n - 1, :lists.reverse(gc, acc)) + [] -> {acc, []} + end + end + + defp enum_reverse_at([h | t], n, acc) when n > 0, do: enum_reverse_at(t, n - 1, [h | acc]) + defp enum_reverse_at(rest, _, acc), do: {acc, rest} + + defp last_line(binary) when is_binary(binary) do + [last_line | lines_reverse] = + binary + |> String.split(["\r\n", "\n"]) + |> Enum.reverse() + + prepend_cursor_lines(lines_reverse, String.to_charlist(last_line)) + end + + defp last_line(charlist) when is_list(charlist) do + [last_line | lines_reverse] = + charlist + |> :string.replace(~c"\r\n", ~c"\n", :all) + |> :string.join(~c"") + |> :string.split(~c"\n", :all) + |> Enum.reverse() + + prepend_cursor_lines(lines_reverse, last_line) + end + + defp prepend_cursor_lines(lines, last_line) do + with [line | lines] <- lines, + {trimmed_line, incomplete?} = ends_as_incomplete(to_charlist(line), [], true), + true <- incomplete? or starts_with_dot?(last_line) do + prepend_cursor_lines(lines, Enum.reverse(trimmed_line, last_line)) + else + _ -> last_line + end + end + + defp starts_with_dot?([?. | _]), do: true + defp starts_with_dot?([h | t]) when h in @space, do: starts_with_dot?(t) + defp starts_with_dot?(_), do: false + + defp ends_as_incomplete([?# | _], acc, incomplete?), + do: {acc, incomplete?} + + defp ends_as_incomplete([h | t], acc, _incomplete?) when h in [?(, ?.], + do: ends_as_incomplete(t, [h | acc], true) + + defp ends_as_incomplete([h | t], acc, incomplete?) when h in @space, + do: ends_as_incomplete(t, [h | acc], incomplete?) + + defp ends_as_incomplete([h | t], acc, _incomplete?), + do: ends_as_incomplete(t, [h | acc], false) + + defp ends_as_incomplete([], acc, incomplete?), + do: {acc, incomplete?} + + defp surround_line(binary, line, column) when is_binary(binary) do + binary + |> String.split(["\r\n", "\n"]) + |> Enum.map(&String.to_charlist/1) + |> surround_lines(line, column) + end + + defp surround_line(charlist, line, column) when is_list(charlist) do + charlist + |> :string.replace(~c"\r\n", ~c"\n", :all) + |> :string.join(~c"") + |> :string.split(~c"\n", :all) + |> surround_lines(line, column) + end + + defp surround_lines(lines, line, column) do + {lines_before_reverse, cursor_line, lines_after} = split_at(lines, line, []) + {trimmed_cursor_line, incomplete?} = ends_as_incomplete(to_charlist(cursor_line), [], true) + + reversed_cursor_line = + if column - 1 > length(trimmed_cursor_line) do + # Don't strip comments if cursor is inside a comment + Enum.reverse(cursor_line) + else + trimmed_cursor_line + end + + {cursor_line, after_lengths} = + append_surround_lines(lines_after, [], [reversed_cursor_line], incomplete?) + + {cursor_line, before_lengths} = prepend_surround_lines(lines_before_reverse, [], cursor_line) + {cursor_line, before_lengths, [length(reversed_cursor_line) | after_lengths]} + end + + defp split_at([line], _, acc), do: {acc, line, []} + defp split_at([line | lines], 1, acc), do: {acc, line, lines} + defp split_at([line | lines], count, acc), do: split_at(lines, count - 1, [line | acc]) + + defp prepend_surround_lines(lines, lengths, last_line) do + with [line | lines] <- lines, + {trimmed_line, incomplete?} = ends_as_incomplete(to_charlist(line), [], true), + true <- incomplete? or starts_with_dot?(last_line) do + lengths = [length(trimmed_line) | lengths] + prepend_surround_lines(lines, lengths, Enum.reverse(trimmed_line, last_line)) + else + _ -> {last_line, Enum.reverse(lengths)} + end + end + + defp append_surround_lines(lines, lengths, acc_lines, incomplete?) do + with [line | lines] <- lines, + line = to_charlist(line), + true <- incomplete? or starts_with_dot?(line) do + {trimmed_line, incomplete?} = ends_as_incomplete(line, [], true) + lengths = [length(trimmed_line) | lengths] + append_surround_lines(lines, lengths, [trimmed_line | acc_lines], incomplete?) + else + _ -> {Enum.reduce(acc_lines, [], &Enum.reverse/2), Enum.reverse(lengths)} + end + end + + defp to_multiline_range(:none, _, _, _), do: :none + + defp to_multiline_range( + %{begin: {begin_line, begin_column}, end: {end_line, end_column}} = context, + prepended, + lines_before_lengths, + lines_current_and_after_lengths + ) do + {begin_line, begin_column} = + Enum.reduce_while(lines_before_lengths, {begin_line, begin_column - prepended}, fn + line_length, {acc_line, acc_column} -> + if acc_column < 1 do + {:cont, {acc_line - 1, acc_column + line_length}} + else + {:halt, {acc_line, acc_column}} + end + end) + + {end_line, end_column} = + Enum.reduce_while(lines_current_and_after_lengths, {end_line, end_column - prepended}, fn + line_length, {acc_line, acc_column} -> + if acc_column > line_length + 1 do + {:cont, {acc_line + 1, acc_column - line_length}} + else + {:halt, {acc_line, acc_column}} + end + end) + + %{context | begin: {begin_line, begin_column}, end: {end_line, end_column}} + end + + @doc """ + Receives a string and returns a quoted expression + with the cursor AST position within its parent expression. + + This function receives a string with an Elixir code fragment, + representing a cursor position, and converts such string to + AST with the inclusion of special `__cursor__()` node representing + the cursor position within its container (i.e. its parent). + + For example, take this code, which would be given as input: + + max(some_value, + + This function will return the AST equivalent to: + + max(some_value, __cursor__()) + + In other words, this function is capable of closing any open + brackets and insert the cursor position. Other content at the + cursor position which is not a parent is discarded. + For example, if this is given as input: + + max(some_value, another_val + + It will return the same AST: + + max(some_value, __cursor__()) + + Similarly, if only this is given: + + max(some_va + + Then it returns: + + max(__cursor__()) + + Calls without parenthesis are also supported, as we assume the + brackets are implicit. + + Tuples, lists, maps, and binaries all retain the cursor position: + + max(some_value, [1, 2, + + Returns the following AST: + + max(some_value, [1, 2, __cursor__()]) + + Keyword lists (and do-end blocks) are also retained. The following: + + if(some_value, do: + if(some_value, do: :token + if(some_value, do: 1 + val + + all return: + + if(some_value, do: __cursor__()) + + For multi-line blocks, all previous lines are preserved. + + The AST returned by this function is not safe to evaluate but + it can be analyzed and expanded. + + ## Examples + + Function call: + + iex> Code.Fragment.container_cursor_to_quoted("max(some_value, ") + {:ok, {:max, [line: 1], [{:some_value, [line: 1], nil}, {:__cursor__, [line: 1], []}]}} + + Containers (for example, a list): + + iex> Code.Fragment.container_cursor_to_quoted("[some, value") + {:ok, [{:some, [line: 1], nil}, {:__cursor__, [line: 1], []}]} + + If an expression is complete, then the whole expression is discarded + and only the parent is returned: + + iex> Code.Fragment.container_cursor_to_quoted("if(is_atom(var)") + {:ok, {:if, [line: 1], [{:__cursor__, [line: 1], []}]}} + + this means complete expressions themselves return only the cursor: + + iex> Code.Fragment.container_cursor_to_quoted("if(is_atom(var))") + {:ok, {:__cursor__, [line: 1], []}} + + Operators are also included from Elixir v1.15: + + iex> Code.Fragment.container_cursor_to_quoted("foo +") + {:ok, {:+, [line: 1], [{:foo, [line: 1], nil}, {:__cursor__, [line: 1], []}]}} + + ## Options + + * `:file` - the filename to be reported in case of parsing errors. + Defaults to `"nofile"`. + + * `:line` - the starting line of the string being parsed. + Defaults to 1. + + * `:column` - the starting column of the string being parsed. + Defaults to 1. + + * `:columns` - when `true`, attach a `:column` key to the quoted + metadata. Defaults to `false`. + + * `:token_metadata` - when `true`, includes token-related + metadata in the expression AST, such as metadata for `do` and `end` + tokens, for closing tokens, end of expressions, as well as delimiters + for sigils. See `t:Macro.metadata/0`. Defaults to `false`. + + * `:literal_encoder` - a function to encode literals in the AST. + See the documentation for `Code.string_to_quoted/2` for more information. + + """ + @doc since: "1.13.0" + @spec container_cursor_to_quoted(List.Chars.t(), keyword()) :: + {:ok, Macro.t()} | {:error, {location :: keyword, binary | {binary, binary}, binary}} + def container_cursor_to_quoted(fragment, opts \\ []) do + opts = Keyword.take(opts, [:columns, :token_metadata, :literal_encoder]) + opts = [cursor_completion: true, emit_warnings: false] ++ opts + + file = Keyword.get(opts, :file, "nofile") + line = Keyword.get(opts, :line, 1) + column = Keyword.get(opts, :column, 1) + + case :future_elixir_tokenizer.tokenize(to_charlist(fragment), line, column, opts) do + {:ok, line, column, _warnings, rev_tokens, rev_terminators} -> + tokens = :lists.reverse(rev_tokens, rev_terminators) + + case :future_elixir.tokens_to_quoted(tokens, file, opts) do + {:ok, ast} -> + {:ok, ast} + + {:error, error} -> + # In case parsing fails, we give it another shot but handling fn/do/else/catch/rescue/after. + tokens = + :lists.reverse( + rev_tokens, + [{:stab_op, {line, column, nil}, :->}, {nil, {line, column + 2, nil}}] ++ + Enum.map(rev_terminators, fn tuple -> + {line, column, info} = elem(tuple, 1) + put_elem(tuple, 1, {line, column + 5, info}) + end) + ) + + case :future_elixir.tokens_to_quoted(tokens, file, opts) do + {:ok, ast} -> {:ok, ast} + {:error, _} -> {:error, error} + end + end + + {:error, info, _rest, _warnings, _so_far} -> + {:error, :future_elixir.format_token_error(info)} + end + end +end diff --git a/forge/lib/future/code/indentifier.ex b/forge/lib/future/code/indentifier.ex new file mode 100644 index 00000000..ab4aac3d --- /dev/null +++ b/forge/lib/future/code/indentifier.ex @@ -0,0 +1,153 @@ +# Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/lib/code/identifier.ex +defmodule Future.Code.Identifier do + @moduledoc false + + @doc """ + Checks if the given identifier is an unary op. + + ## Examples + + iex> Code.Identifier.unary_op(:+) + {:non_associative, 300} + + """ + @spec unary_op(atom) :: {:non_associative, precedence :: pos_integer} | :error + def unary_op(op) do + cond do + op in [:&, :...] -> {:non_associative, 90} + op in [:!, :^, :not, :+, :-, :"~~~"] -> {:non_associative, 300} + op in [:@] -> {:non_associative, 320} + true -> :error + end + end + + @doc """ + Checks if the given identifier is a binary op. + + ## Examples + + iex> Code.Identifier.binary_op(:+) + {:left, 210} + + """ + @spec binary_op(atom) :: {:left | :right, precedence :: pos_integer} | :error + def binary_op(op) do + cond do + op in [:<-, :\\] -> {:left, 40} + op in [:when] -> {:right, 50} + op in [:"::"] -> {:right, 60} + op in [:|] -> {:right, 70} + op in [:=] -> {:right, 100} + op in [:||, :|||, :or] -> {:left, 120} + op in [:&&, :&&&, :and] -> {:left, 130} + op in [:==, :!=, :=~, :===, :!==] -> {:left, 140} + op in [:<, :<=, :>=, :>] -> {:left, 150} + op in [:|>, :<<<, :>>>, :<~, :~>, :<<~, :~>>, :<~>, :"<|>"] -> {:left, 160} + op in [:in] -> {:left, 170} + op in [:"^^^"] -> {:left, 180} + op in [:++, :--, :.., :<>, :+++, :---] -> {:right, 200} + op in [:+, :-] -> {:left, 210} + op in [:*, :/] -> {:left, 220} + op in [:**] -> {:left, 230} + op in [:.] -> {:left, 310} + true -> :error + end + end + + @doc """ + Extracts the name and arity of the parent from the anonymous function identifier. + """ + # Example of this format: -NAME/ARITY-fun-COUNT- + def extract_anonymous_fun_parent(atom) when is_atom(atom) do + with "-" <> rest <- Atom.to_string(atom), + [trailing | reversed] = rest |> String.split("/") |> Enum.reverse(), + [arity, _inner, _count, ""] <- String.split(trailing, "-") do + {reversed |> Enum.reverse() |> Enum.join("/") |> String.to_atom(), arity} + else + _ -> :error + end + end + + @doc """ + Escapes the given identifier. + """ + @spec escape(binary(), char() | nil, :infinity | non_neg_integer, (char() -> iolist() | false)) :: + {escaped :: iolist(), remaining :: binary()} + def escape(binary, char, limit \\ :infinity, fun \\ &escape_map/1) + when ((char in 0..0x10FFFF or is_nil(char)) and limit == :infinity) or + (is_integer(limit) and limit >= 0) do + escape(binary, char, limit, [], fun) + end + + defp escape(<<_, _::binary>> = binary, _char, 0, acc, _fun) do + {acc, binary} + end + + defp escape(<>, char, count, acc, fun) do + escape(t, char, decrement(count), [acc | [?\\, char]], fun) + end + + defp escape(<>, char, count, acc, fun) do + escape(t, char, decrement(count), [acc | [?\\, ?#, ?{]], fun) + end + + defp escape(<>, char, count, acc, fun) do + escaped = if value = fun.(h), do: value, else: escape_char(h) + escape(t, char, decrement(count), [acc | escaped], fun) + end + + defp escape(<>, char, count, acc, fun) do + escape(t, char, decrement(count), [acc | [?\\, ?x, to_hex(a), to_hex(b)]], fun) + end + + defp escape(<<>>, _char, _count, acc, _fun) do + {acc, <<>>} + end + + defp escape_char(0), do: [?\\, ?0] + + @escaped_bom :binary.bin_to_list("\\uFEFF") + defp escape_char(65279), do: @escaped_bom + + defp escape_char(char) + when char in 0x20..0x7E + when char in 0xA0..0xD7FF + when char in 0xE000..0xFFFD + when char in 0x10000..0x10FFFF do + <> + end + + defp escape_char(char) when char < 0x100 do + <> = <> + [?\\, ?x, to_hex(a), to_hex(b)] + end + + defp escape_char(char) when char < 0x10000 do + <> = <> + [?\\, ?x, ?{, to_hex(a), to_hex(b), to_hex(c), to_hex(d), ?}] + end + + defp escape_char(char) when char < 0x1000000 do + <> = <> + [?\\, ?x, ?{, to_hex(a), to_hex(b), to_hex(c), to_hex(d), to_hex(e), to_hex(f), ?}] + end + + defp escape_map(?\a), do: [?\\, ?a] + defp escape_map(?\b), do: [?\\, ?b] + defp escape_map(?\d), do: [?\\, ?d] + defp escape_map(?\e), do: [?\\, ?e] + defp escape_map(?\f), do: [?\\, ?f] + defp escape_map(?\n), do: [?\\, ?n] + defp escape_map(?\r), do: [?\\, ?r] + defp escape_map(?\t), do: [?\\, ?t] + defp escape_map(?\v), do: [?\\, ?v] + defp escape_map(?\\), do: [?\\, ?\\] + defp escape_map(_), do: false + + @compile {:inline, to_hex: 1, decrement: 1} + defp to_hex(c) when c in 0..9, do: ?0 + c + defp to_hex(c) when c in 10..15, do: ?A + c - 10 + + defp decrement(:infinity), do: :infinity + defp decrement(counter), do: counter - 1 +end diff --git a/forge/lib/future/code/typespec.ex b/forge/lib/future/code/typespec.ex new file mode 100644 index 00000000..3b2cb923 --- /dev/null +++ b/forge/lib/future/code/typespec.ex @@ -0,0 +1,433 @@ +# Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/lib/code/typespec.ex +defmodule Future.Code.Typespec do + @moduledoc false + + @doc """ + Converts a spec clause back to Elixir quoted expression. + """ + @spec spec_to_quoted(atom, tuple) :: {atom, keyword, [Macro.t()]} + def spec_to_quoted(name, spec) + + def spec_to_quoted(name, {:type, anno, :fun, [{:type, _, :product, args}, result]}) + when is_atom(name) do + meta = meta(anno) + body = {name, meta, Enum.map(args, &typespec_to_quoted/1)} + + vars = + for type_expr <- args ++ [result], + var <- collect_vars(type_expr), + uniq: true, + do: {var, {:var, meta, nil}} + + spec = {:"::", meta, [body, typespec_to_quoted(result)]} + + if vars == [] do + spec + else + {:when, meta, [spec, vars]} + end + end + + def spec_to_quoted(name, {:type, anno, :fun, []}) when is_atom(name) do + meta = meta(anno) + {:"::", meta, [{name, meta, []}, quote(do: term)]} + end + + def spec_to_quoted(name, {:type, anno, :bounded_fun, [type, constrs]}) when is_atom(name) do + meta = meta(anno) + {:type, _, :fun, [{:type, _, :product, args}, result]} = type + + guards = + for {:type, _, :constraint, [{:atom, _, :is_subtype}, [{:var, _, var}, type]]} <- constrs do + {erl_to_ex_var(var), typespec_to_quoted(type)} + end + + ignore_vars = Keyword.keys(guards) + + vars = + for type_expr <- args ++ [result], + var <- collect_vars(type_expr), + var not in ignore_vars, + uniq: true, + do: {var, {:var, meta, nil}} + + args = for arg <- args, do: typespec_to_quoted(arg) + + when_args = [ + {:"::", meta, [{name, meta, args}, typespec_to_quoted(result)]}, + guards ++ vars + ] + + {:when, meta, when_args} + end + + @doc """ + Converts a type clause back to Elixir AST. + """ + def type_to_quoted(type) + + def type_to_quoted({{:record, record}, fields, args}) when is_atom(record) do + fields = for field <- fields, do: typespec_to_quoted(field) + args = for arg <- args, do: typespec_to_quoted(arg) + type = {:{}, [], [record | fields]} + quote(do: unquote(record)(unquote_splicing(args)) :: unquote(type)) + end + + def type_to_quoted({name, type, args}) when is_atom(name) do + args = for arg <- args, do: typespec_to_quoted(arg) + quote(do: unquote(name)(unquote_splicing(args)) :: unquote(typespec_to_quoted(type))) + end + + @doc """ + Returns all types available from the module's BEAM code. + + The result is returned as a list of tuples where the first + element is the type (`:typep`, `:type` and `:opaque`). + + The module must have a corresponding BEAM file which can be + located by the runtime system. The types will be in the Erlang + Abstract Format. + """ + @spec fetch_types(module | binary) :: {:ok, [tuple]} | :error + def fetch_types(module) when is_atom(module) or is_binary(module) do + case typespecs_abstract_code(module) do + {:ok, abstract_code} -> + exported_types = for {:attribute, _, :export_type, types} <- abstract_code, do: types + exported_types = List.flatten(exported_types) + + types = + for {:attribute, _, kind, {name, _, args} = type} <- abstract_code, + kind in [:opaque, :type] do + cond do + kind == :opaque -> {:opaque, type} + {name, length(args)} in exported_types -> {:type, type} + true -> {:typep, type} + end + end + + {:ok, types} + + _ -> + :error + end + end + + @doc """ + Returns all specs available from the module's BEAM code. + + The result is returned as a list of tuples where the first + element is spec name and arity and the second is the spec. + + The module must have a corresponding BEAM file which can be + located by the runtime system. The types will be in the Erlang + Abstract Format. + """ + @spec fetch_specs(module | binary) :: {:ok, [tuple]} | :error + def fetch_specs(module) when is_atom(module) or is_binary(module) do + case typespecs_abstract_code(module) do + {:ok, abstract_code} -> + {:ok, for({:attribute, _, :spec, value} <- abstract_code, do: value)} + + :error -> + :error + end + end + + @doc """ + Returns all callbacks available from the module's BEAM code. + + The result is returned as a list of tuples where the first + element is spec name and arity and the second is the spec. + + The module must have a corresponding BEAM file + which can be located by the runtime system. The types will be + in the Erlang Abstract Format. + """ + @spec fetch_callbacks(module | binary) :: {:ok, [tuple]} | :error + def fetch_callbacks(module) when is_atom(module) or is_binary(module) do + case typespecs_abstract_code(module) do + {:ok, abstract_code} -> + {:ok, for({:attribute, _, :callback, value} <- abstract_code, do: value)} + + :error -> + :error + end + end + + defp typespecs_abstract_code(module) do + with {module, binary} <- get_module_and_beam(module), + {:ok, {_, [debug_info: {:debug_info_v1, backend, data}]}} <- + :beam_lib.chunks(binary, [:debug_info]) do + case data do + {:elixir_v1, %{}, specs} -> + # Fast path to avoid translation to Erlang from Elixir. + {:ok, specs} + + _ -> + case backend.debug_info(:erlang_v1, module, data, []) do + {:ok, abstract_code} -> {:ok, abstract_code} + _ -> :error + end + end + else + _ -> :error + end + end + + defp get_module_and_beam(module) when is_atom(module) do + with {^module, beam, _filename} <- :code.get_object_code(module), + info_pairs when is_list(info_pairs) <- :beam_lib.info(beam), + {:ok, ^module} <- Keyword.fetch(info_pairs, :module) do + {module, beam} + else + _ -> :error + end + end + + defp get_module_and_beam(beam) when is_binary(beam) do + case :beam_lib.info(beam) do + [_ | _] = info -> {info[:module], beam} + _ -> :error + end + end + + ## To AST conversion + + defp collect_vars({:ann_type, _anno, args}) when is_list(args) do + [] + end + + defp collect_vars({:type, _anno, _kind, args}) when is_list(args) do + Enum.flat_map(args, &collect_vars/1) + end + + defp collect_vars({:remote_type, _anno, args}) when is_list(args) do + Enum.flat_map(args, &collect_vars/1) + end + + defp collect_vars({:typed_record_field, _anno, type}) do + collect_vars(type) + end + + defp collect_vars({:paren_type, _anno, [type]}) do + collect_vars(type) + end + + defp collect_vars({:var, _anno, var}) do + [erl_to_ex_var(var)] + end + + defp collect_vars(_) do + [] + end + + defp typespec_to_quoted({:user_type, anno, name, args}) do + args = for arg <- args, do: typespec_to_quoted(arg) + {name, meta(anno), args} + end + + defp typespec_to_quoted({:type, anno, :tuple, :any}) do + {:tuple, meta(anno), []} + end + + defp typespec_to_quoted({:type, anno, :tuple, args}) do + args = for arg <- args, do: typespec_to_quoted(arg) + {:{}, meta(anno), args} + end + + defp typespec_to_quoted({:type, _anno, :list, [{:type, _, :union, unions} = arg]}) do + case unpack_typespec_kw(unions, []) do + {:ok, ast} -> ast + :error -> [typespec_to_quoted(arg)] + end + end + + defp typespec_to_quoted({:type, anno, :list, []}) do + {:list, meta(anno), []} + end + + defp typespec_to_quoted({:type, _anno, :list, [arg]}) do + [typespec_to_quoted(arg)] + end + + defp typespec_to_quoted({:type, anno, :nonempty_list, []}) do + [{:..., meta(anno), nil}] + end + + defp typespec_to_quoted({:type, anno, :nonempty_list, [arg]}) do + [typespec_to_quoted(arg), {:..., meta(anno), nil}] + end + + defp typespec_to_quoted({:type, anno, :map, :any}) do + {:map, meta(anno), []} + end + + defp typespec_to_quoted({:type, anno, :map, fields}) do + fields = + Enum.map(fields, fn + {:type, _, :map_field_assoc, :any} -> + {{:optional, [], [{:any, [], []}]}, {:any, [], []}} + + {:type, _, :map_field_exact, [{:atom, _, k}, v]} -> + {k, typespec_to_quoted(v)} + + {:type, _, :map_field_exact, [k, v]} -> + {{:required, [], [typespec_to_quoted(k)]}, typespec_to_quoted(v)} + + {:type, _, :map_field_assoc, [k, v]} -> + {{:optional, [], [typespec_to_quoted(k)]}, typespec_to_quoted(v)} + end) + + case List.keytake(fields, :__struct__, 0) do + {{:__struct__, struct}, fields_pruned} when is_atom(struct) and struct != nil -> + map_pruned = {:%{}, meta(anno), fields_pruned} + {:%, meta(anno), [struct, map_pruned]} + + _ -> + {:%{}, meta(anno), fields} + end + end + + defp typespec_to_quoted({:type, anno, :binary, [arg1, arg2]}) do + [arg1, arg2] = for arg <- [arg1, arg2], do: typespec_to_quoted(arg) + line = meta(anno)[:line] + + case {typespec_to_quoted(arg1), typespec_to_quoted(arg2)} do + {arg1, 0} -> + quote(line: line, do: <<_::unquote(arg1)>>) + + {0, arg2} -> + quote(line: line, do: <<_::_*unquote(arg2)>>) + + {arg1, arg2} -> + quote(line: line, do: <<_::unquote(arg1), _::_*unquote(arg2)>>) + end + end + + defp typespec_to_quoted({:type, anno, :union, args}) do + args = for arg <- args, do: typespec_to_quoted(arg) + Enum.reduce(Enum.reverse(args), fn arg, expr -> {:|, meta(anno), [arg, expr]} end) + end + + defp typespec_to_quoted({:type, anno, :fun, [{:type, _, :product, args}, result]}) do + args = for arg <- args, do: typespec_to_quoted(arg) + [{:->, meta(anno), [args, typespec_to_quoted(result)]}] + end + + defp typespec_to_quoted({:type, anno, :fun, [args, result]}) do + [{:->, meta(anno), [[typespec_to_quoted(args)], typespec_to_quoted(result)]}] + end + + defp typespec_to_quoted({:type, anno, :fun, []}) do + typespec_to_quoted({:type, anno, :fun, [{:type, anno, :any}, {:type, anno, :any, []}]}) + end + + defp typespec_to_quoted({:type, anno, :range, [left, right]}) do + {:.., meta(anno), [typespec_to_quoted(left), typespec_to_quoted(right)]} + end + + defp typespec_to_quoted({:type, _anno, nil, []}) do + [] + end + + defp typespec_to_quoted({:type, anno, name, args}) do + args = for arg <- args, do: typespec_to_quoted(arg) + {name, meta(anno), args} + end + + defp typespec_to_quoted({:var, anno, var}) do + {erl_to_ex_var(var), meta(anno), nil} + end + + defp typespec_to_quoted({:op, anno, op, arg}) do + {op, meta(anno), [typespec_to_quoted(arg)]} + end + + defp typespec_to_quoted({:remote_type, anno, [mod, name, args]}) do + remote_type(anno, mod, name, args) + end + + defp typespec_to_quoted({:ann_type, anno, [var, type]}) do + {:"::", meta(anno), [typespec_to_quoted(var), typespec_to_quoted(type)]} + end + + defp typespec_to_quoted( + {:typed_record_field, {:record_field, anno1, {:atom, anno2, name}}, type} + ) do + typespec_to_quoted({:ann_type, anno1, [{:var, anno2, name}, type]}) + end + + defp typespec_to_quoted({:type, _, :any}) do + quote(do: ...) + end + + defp typespec_to_quoted({:paren_type, _, [type]}) do + typespec_to_quoted(type) + end + + defp typespec_to_quoted({type, _anno, atom}) when is_atom(type) do + atom + end + + defp typespec_to_quoted(other), do: other + + ## Helpers + + defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :charlist}, []) do + typespec_to_quoted({:type, anno, :charlist, []}) + end + + defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :nonempty_charlist}, []) do + typespec_to_quoted({:type, anno, :nonempty_charlist, []}) + end + + defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :struct}, []) do + typespec_to_quoted({:type, anno, :struct, []}) + end + + defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :as_boolean}, [arg]) do + typespec_to_quoted({:type, anno, :as_boolean, [arg]}) + end + + defp remote_type(anno, {:atom, _, :elixir}, {:atom, _, :keyword}, args) do + typespec_to_quoted({:type, anno, :keyword, args}) + end + + defp remote_type(anno, mod, name, args) do + args = for arg <- args, do: typespec_to_quoted(arg) + dot = {:., meta(anno), [typespec_to_quoted(mod), typespec_to_quoted(name)]} + {dot, meta(anno), args} + end + + defp erl_to_ex_var(var) do + case Atom.to_string(var) do + <<"_", c::utf8, rest::binary>> -> + String.to_atom("_#{String.downcase(<>)}#{rest}") + + <> -> + String.to_atom("#{String.downcase(<>)}#{rest}") + end + end + + defp unpack_typespec_kw([{:type, _, :tuple, [{:atom, _, atom}, type]} | t], acc) do + unpack_typespec_kw(t, [{atom, typespec_to_quoted(type)} | acc]) + end + + defp unpack_typespec_kw([], acc) do + {:ok, Enum.reverse(acc)} + end + + defp unpack_typespec_kw(_, _acc) do + :error + end + + defp meta(anno) do + case :erl_anno.location(anno) do + {line, column} -> + [line: line, column: column] + + line when is_integer(line) -> + [line: line] + end + end +end diff --git a/forge/lib/future/macro.ex b/forge/lib/future/macro.ex new file mode 100644 index 00000000..29f83b43 --- /dev/null +++ b/forge/lib/future/macro.ex @@ -0,0 +1,95 @@ +# Copied some code from https://github.com/elixir-lang/elixir/blob/44c18a3/lib/elixir/lib/macro.ex#L440 +# only copied the `path/2` +import Kernel, except: [to_string: 1] + +defmodule Future.Macro do + @doc """ + Returns the path to the node in `ast` which `fun` returns `true`. + + The path is a list, starting with the node in which `fun` returns + true, followed by all of its parents. + + Computing the path can be an efficient operation when you want + to find a particular node in the AST within its context and then + assert something about it. + + ## Examples + + iex> Macro.path(quote(do: [1, 2, 3]), & &1 == 3) + [3, [1, 2, 3]] + + iex> Macro.path(quote(do: Foo.bar(3)), & &1 == 3) + [3, quote(do: Foo.bar(3))] + + iex> Macro.path(quote(do: %{foo: [bar: :baz]}), & &1 == :baz) + [ + :baz, + {:bar, :baz}, + [bar: :baz], + {:foo, [bar: :baz]}, + {:%{}, [], [foo: [bar: :baz]]} + ] + + """ + @doc since: "1.14.0" + def path(ast, fun) when is_function(fun, 1) do + path(ast, [], fun) + end + + defp path({form, _, args} = ast, acc, fun) when is_atom(form) do + acc = [ast | acc] + + if fun.(ast) do + acc + else + path_args(args, acc, fun) + end + end + + defp path({form, _meta, args} = ast, acc, fun) do + acc = [ast | acc] + + if fun.(ast) do + acc + else + path(form, acc, fun) || path_args(args, acc, fun) + end + end + + defp path({left, right} = ast, acc, fun) do + acc = [ast | acc] + + if fun.(ast) do + acc + else + path(left, acc, fun) || path(right, acc, fun) + end + end + + defp path(list, acc, fun) when is_list(list) do + acc = [list | acc] + + if fun.(list) do + acc + else + path_list(list, acc, fun) + end + end + + defp path(ast, acc, fun) do + if fun.(ast) do + [ast | acc] + end + end + + defp path_args(atom, _acc, _fun) when is_atom(atom), do: nil + defp path_args(list, acc, fun) when is_list(list), do: path_list(list, acc, fun) + + defp path_list([], _acc, _fun) do + nil + end + + defp path_list([arg | args], acc, fun) do + path(arg, acc, fun) || path_list(args, acc, fun) + end +end diff --git a/forge/lib/mix/tasks/hooks.ex b/forge/lib/mix/tasks/hooks.ex new file mode 100644 index 00000000..e24c653c --- /dev/null +++ b/forge/lib/mix/tasks/hooks.ex @@ -0,0 +1,39 @@ +defmodule Mix.Tasks.Hooks do + def run(_) do + sources = + [File.cwd!(), "hooks", "**"] + |> Path.join() + |> Path.wildcard() + + sources_count = length(sources) + hook_text = pluralize(sources_count, "hook", "hooks") + Mix.Shell.IO.info("Copying #{sources_count} #{hook_text}") + dest_dir = Path.join([File.cwd!(), ".git", "hooks"]) + + for source <- sources, + dest_path = Path.join(dest_dir, Path.basename(source)) do + if File.exists?(dest_path) do + File.rm(dest_path) + end + + message = + case File.cp(source, dest_path) do + :ok -> + " #{Path.basename(source)}: ✅" + + {:error, reason} -> + " #{Path.basename(source)} ❌ #{inspect(reason)}" + end + + Mix.Shell.IO.info(message) + end + end + + defp pluralize(count, singular, plural) do + if count == 1 do + singular + else + plural + end + end +end diff --git a/forge/mix.exs b/forge/mix.exs new file mode 100644 index 00000000..4404cdfc --- /dev/null +++ b/forge/mix.exs @@ -0,0 +1,30 @@ +defmodule Forge.MixProject do + use Mix.Project + + def project do + [ + app: :forge, + version: "0.1.0", + elixir: "~> 1.17", + compilers: [:yecc] ++ Mix.compilers(), + start_permanent: Mix.env() == :prod, + deps: deps() + ] + end + + # Run "mix help compile.app" to learn about applications. + def application do + [ + extra_applications: [:logger] + ] + end + + # Run "mix help deps" to learn about dependencies. + defp deps do + [ + {:sourceror, "~> 1.0"} + # {:dep_from_hexpm, "~> 0.3.0"}, + # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: "0.1.0"} + ] + end +end diff --git a/forge/src/future_elixir.erl b/forge/src/future_elixir.erl new file mode 100644 index 00000000..4580963f --- /dev/null +++ b/forge/src/future_elixir.erl @@ -0,0 +1,542 @@ +%% Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/src/elixir.erl +%% Main entry point for Elixir functions. All of those functions are +%% private to the Elixir compiler and reserved to be used by Elixir only. +-module(future_elixir). +-behaviour(application). +-export([start_cli/0, start/0]). +-export([start/2, stop/1, config_change/3]). +-export([ + string_to_tokens/5, tokens_to_quoted/3, 'string_to_quoted!'/5, + env_for_eval/1, quoted_to_erl/2, eval_forms/3, eval_quoted/3, + eval_quoted/4, eval_local_handler/2, eval_external_handler/3, + format_token_error/1 +]). +-include("future_elixir.hrl"). +-define(system, 'Elixir.System'). +-define(elixir_eval_env, {elixir, eval_env}). + +%% Top level types +%% TODO: Remove char_list type on v2.0 +-export_type([charlist/0, char_list/0, nonempty_charlist/0, struct/0, as_boolean/1, keyword/0, keyword/1]). +-type charlist() :: string(). +-type char_list() :: string(). +-type nonempty_charlist() :: nonempty_string(). +-type as_boolean(T) :: T. +-type keyword() :: [{atom(), any()}]. +-type keyword(T) :: [{atom(), T}]. +-type struct() :: #{'__struct__' := atom(), atom() => any()}. + +%% OTP Application API +%% TODO: Remove Erlang/OTP 26+ checks + +load_paths(OTP, Paths) when OTP >= 26 -> code:add_pathsa(Paths, cache); +load_paths(_OTP, Paths) -> code:add_pathsa(Paths). + +start(_Type, _Args) -> + OTP = parse_otp_release(), + preload_common_modules(), + set_stdio_and_stderr_to_binary_and_maybe_utf8(OTP), + check_file_encoding(file:native_name_encoding()), + + case init:get_argument(elixir_root) of + {ok, [[Root]]} -> + load_paths(OTP, [ + Root ++ "/eex/ebin", + Root ++ "/ex_unit/ebin", + Root ++ "/iex/ebin", + Root ++ "/logger/ebin", + Root ++ "/mix/ebin", + Root ++ "/elixir/ebin" + ]); + _ -> + ok + end, + + case application:get_env(elixir, check_endianness, true) of + true -> check_endianness(); + false -> ok + end, + + case application:get_env(elixir, ansi_enabled) of + {ok, _} -> ok; + undefined -> + %% Remove prim_tty module check as well as checks from scripts on Erlang/OTP 26 + ANSIEnabled = erlang:module_loaded(prim_tty) andalso (prim_tty:isatty(stdout) == true), + application:set_env(elixir, ansi_enabled, ANSIEnabled) + end, + + Tokenizer = case code:ensure_loaded('Elixir.String.Tokenizer') of + {module, Mod} -> Mod; + _ -> future_elixir_tokenizer + end, + + URIConfig = [ + {{uri, <<"ftp">>}, 21}, + {{uri, <<"sftp">>}, 22}, + {{uri, <<"tftp">>}, 69}, + {{uri, <<"http">>}, 80}, + {{uri, <<"https">>}, 443}, + {{uri, <<"ldap">>}, 389}, + {{uri, <<"ws">>}, 80}, + {{uri, <<"wss">>}, 443} + ], + + Config = [ + %% ARGV options + {at_exit, []}, + {argv, []}, + {no_halt, false}, + + %% Compiler options + {docs, true}, + {ignore_already_consolidated, false}, + {ignore_module_conflict, false}, + {on_undefined_variable, raise}, + {parser_options, [{columns, true}]}, + {debug_info, true}, + {warnings_as_errors, false}, + {relative_paths, true}, + {no_warn_undefined, []}, + {tracers, []} + | URIConfig + ], + + elixir_config:static(#{bootstrap => false, identifier_tokenizer => Tokenizer}), + Tab = elixir_config:new(Config), + + case elixir_sup:start_link() of + {ok, Sup} -> + {ok, Sup, Tab}; + {error, _Reason} = Error -> + elixir_config:delete(Tab), + Error + end. + +stop(Tab) -> + elixir_config:delete(Tab). + +config_change(_Changed, _New, _Remove) -> + ok. + +set_stdio_and_stderr_to_binary_and_maybe_utf8(OTP) when OTP >= 26 -> + ok = io:setopts(standard_io, [binary]), + ok; +set_stdio_and_stderr_to_binary_and_maybe_utf8(_OTP) -> + Opts = + case init:get_argument(noshell) of + {ok, _} -> [binary, {encoding, utf8}]; + error -> [binary] + end, + ok = io:setopts(standard_io, Opts), + ok = io:setopts(standard_error, [{encoding, utf8}]), + ok. + +preload_common_modules() -> + %% We attempt to load those modules here so throughout + %% the codebase we can avoid code:ensure_loaded/1 checks. + _ = code:ensure_loaded('Elixir.Kernel'), + _ = code:ensure_loaded('Elixir.Macro.Env'), + ok. + +parse_otp_release() -> + %% Whenever we change this check, we should also change Makefile. + case string:to_integer(erlang:system_info(otp_release)) of + {Num, _} when Num >= 25 -> + Num; + _ -> + io:format(standard_error, "ERROR! Unsupported Erlang/OTP version, expected Erlang/OTP 25+~n", []), + erlang:halt(1) + end. + +check_endianness() -> + case code:ensure_loaded(?system) of + {module, ?system} -> + Endianness = ?system:endianness(), + case ?system:compiled_endianness() of + Endianness -> + ok; + _ -> + io:format(standard_error, + "warning: Elixir is running in a system with a different endianness than the one its " + "source code was compiled in. Please make sure Elixir and all source files were compiled " + "in a machine with the same endianness as the current one: ~ts~n", [Endianness]) + end; + {error, _} -> + ok + end. + +check_file_encoding(Encoding) -> + case Encoding of + latin1 -> + io:format(standard_error, + "warning: the VM is running with native name encoding of latin1 which may cause " + "Elixir to malfunction as it expects utf8. Please ensure your locale is set to UTF-8 " + "(which can be verified by running \"locale\" in your shell) or set the " + "ELIXIR_ERL_OPTIONS=\"+fnu\" environment variable~n", []); + _ -> + ok + end. + +%% Boot and process given options. Invoked by Elixir's script. +%% TODO: Delete prim_tty branches on Erlang/OTP 26. + +start() -> + case code:ensure_loaded(prim_tty) of + {module, _} -> + user_drv:start(#{initial_shell => iex:shell()}); + {error, _} -> + case init:get_argument(elixir_root) of + {ok, [[Root]]} -> code:add_patha(Root ++ "/iex/ebin"); + _ -> ok + end, + 'Elixir.IEx.CLI':deprecated() + end. + +start_cli() -> + {ok, _} = application:ensure_all_started(elixir), + + %% We start the Logger so tools that depend on Elixir + %% always have the Logger directly accessible. However + %% Logger is not a dependency of the Elixir application, + %% which means releases that want to use Logger must + %% always list it as part of its applications. + _ = case code:ensure_loaded('Elixir.Logger') of + {module, _} -> application:start(logger); + {error, _} -> ok + end, + + 'Elixir.Kernel.CLI':main(init:get_plain_arguments()). + +%% EVAL HOOKS + +env_for_eval(#{lexical_tracker := Pid} = Env) -> + NewEnv = Env#{ + context := nil, + context_modules := [], + macro_aliases := [], + versioned_vars := #{} + }, + + case is_pid(Pid) of + true -> + case is_process_alive(Pid) of + true -> + NewEnv; + false -> + 'Elixir.IO':warn( + <<"an __ENV__ with outdated compilation information was given to eval, " + "call Macro.Env.prune_compile_info/1 to prune it">> + ), + NewEnv#{lexical_tracker := nil, tracers := []} + end; + false -> + NewEnv#{tracers := []} + end; +env_for_eval(Opts) when is_list(Opts) -> + Env = elixir_env:new(), + + Line = case lists:keyfind(line, 1, Opts) of + {line, LineOpt} when is_integer(LineOpt) -> LineOpt; + false -> ?key(Env, line) + end, + + File = case lists:keyfind(file, 1, Opts) of + {file, FileOpt} when is_binary(FileOpt) -> FileOpt; + false -> ?key(Env, file) + end, + + Module = case lists:keyfind(module, 1, Opts) of + {module, ModuleOpt} when is_atom(ModuleOpt) -> ModuleOpt; + false -> nil + end, + + FA = case lists:keyfind(function, 1, Opts) of + {function, {Function, Arity}} when is_atom(Function), is_integer(Arity) -> {Function, Arity}; + {function, nil} -> nil; + false -> nil + end, + + TempTracers = case lists:keyfind(tracers, 1, Opts) of + {tracers, TracersOpt} when is_list(TracersOpt) -> TracersOpt; + false -> [] + end, + + Aliases = case lists:keyfind(aliases, 1, Opts) of + {aliases, AliasesOpt} when is_list(AliasesOpt) -> + 'Elixir.IO':warn(<<":aliases option in eval is deprecated">>), + AliasesOpt; + false -> + ?key(Env, aliases) + end, + + Requires = case lists:keyfind(requires, 1, Opts) of + {requires, RequiresOpt} when is_list(RequiresOpt) -> + 'Elixir.IO':warn(<<":requires option in eval is deprecated">>), + ordsets:from_list(RequiresOpt); + false -> + ?key(Env, requires) + end, + + Functions = case lists:keyfind(functions, 1, Opts) of + {functions, FunctionsOpt} when is_list(FunctionsOpt) -> + 'Elixir.IO':warn(<<":functions option in eval is deprecated">>), + FunctionsOpt; + false -> + ?key(Env, functions) + end, + + Macros = case lists:keyfind(macros, 1, Opts) of + {macros, MacrosOpt} when is_list(MacrosOpt) -> + 'Elixir.IO':warn(<<":macros option in eval is deprecated">>), + MacrosOpt; + false -> + ?key(Env, macros) + end, + + %% If there is a dead PID or lexical tracker is nil, + %% we assume the tracers also cannot be (re)used. + {LexicalTracker, Tracers} = case lists:keyfind(lexical_tracker, 1, Opts) of + {lexical_tracker, Pid} when is_pid(Pid) -> + 'Elixir.IO':warn(<<":lexical_tracker option in eval is deprecated">>), + case is_process_alive(Pid) of + true -> {Pid, TempTracers}; + false -> {nil, []} + end; + {lexical_tracker, nil} -> + 'Elixir.IO':warn(<<":lexical_tracker option in eval is deprecated">>), + {nil, []}; + false -> + {nil, TempTracers} + end, + + Env#{ + file := File, module := Module, function := FA, tracers := Tracers, + macros := Macros, functions := Functions, lexical_tracker := LexicalTracker, + requires := Requires, aliases := Aliases, line := Line + }. + +%% Quoted evaluation + +eval_quoted(Tree, Binding, E) -> + eval_quoted(Tree, Binding, E, []). +eval_quoted(Tree, Binding, #{line := Line} = E, Opts) -> + eval_forms(elixir_quote:linify(Line, line, Tree), Binding, E, Opts). + +eval_forms(Tree, Binding, OrigE) -> + eval_forms(Tree, Binding, OrigE, []). +eval_forms(Tree, Binding, OrigE, Opts) -> + Prune = proplists:get_value(prune_binding, Opts, false), + {ExVars, ErlVars, ErlBinding} = elixir_erl_var:load_binding(Binding, Prune), + E = elixir_env:with_vars(OrigE, ExVars), + ExS = elixir_env:env_to_ex(E), + ErlS = elixir_erl_var:from_env(E, ErlVars), + {Erl, NewErlS, NewExS, NewE} = quoted_to_erl(Tree, ErlS, ExS, E), + + case Erl of + {Literal, _, Value} when Literal == atom; Literal == float; Literal == integer -> + if + Prune -> {Value, [], NewE#{versioned_vars := #{}}}; + true -> {Value, Binding, NewE} + end; + + _ -> + Exprs = + case Erl of + {block, _, BlockExprs} -> BlockExprs; + _ -> [Erl] + end, + + %% We use remote names so eval works across Elixir versions. + LocalHandler = {value, fun ?MODULE:eval_local_handler/2}, + ExternalHandler = {value, fun ?MODULE:eval_external_handler/3}, + + {value, Value, NewBinding} = + try + %% ?elixir_eval_env is used by the external handler. + %% + %% The reason why we use the process dictionary to pass the environment + %% is because we want to avoid passing closures to erl_eval, as that + %% would effectively tie the eval code to the Elixir version and it is + %% best if it depends solely on Erlang/OTP. + %% + %% The downside is that functions that escape the eval context will no + %% longer have the original environment they came from. + erlang:put(?elixir_eval_env, NewE), + erl_eval:exprs(Exprs, ErlBinding, LocalHandler, ExternalHandler) + after + erlang:erase(?elixir_eval_env) + end, + + PruneBefore = if Prune -> length(Binding); true -> -1 end, + + {DumpedBinding, DumpedVars} = + elixir_erl_var:dump_binding(NewBinding, NewErlS, NewExS, PruneBefore), + + {Value, DumpedBinding, NewE#{versioned_vars := DumpedVars}} + end. + +eval_local_handler(FunName, Args) -> + {current_stacktrace, Stack} = erlang:process_info(self(), current_stacktrace), + Opts = [{module, nil}, {function, FunName}, {arity, length(Args)}, {reason, 'undefined local'}], + Exception = 'Elixir.UndefinedFunctionError':exception(Opts), + erlang:raise(error, Exception, Stack). + +eval_external_handler(Ann, FunOrModFun, Args) -> + try + case FunOrModFun of + {Mod, Fun} -> apply(Mod, Fun, Args); + Fun -> apply(Fun, Args) + end + catch + Kind:Reason:Stacktrace -> + %% Take everything up to the Elixir module + Pruned = + lists:takewhile(fun + ({elixir,_,_,_}) -> false; + (_) -> true + end, Stacktrace), + + Caller = + lists:dropwhile(fun + ({elixir,_,_,_}) -> false; + (_) -> true + end, Stacktrace), + + %% Now we prune any shared code path from erl_eval + {current_stacktrace, Current} = + erlang:process_info(self(), current_stacktrace), + + %% We need to make sure that we don't generate more + %% frames than supported. So we do our best to drop + %% from the Caller, but if the caller has no frames, + %% we need to drop from Pruned. + {DroppedCaller, ToDrop} = + case Caller of + [] -> {[], true}; + _ -> {lists:droplast(Caller), false} + end, + + Reversed = drop_common(lists:reverse(Current), lists:reverse(Pruned), ToDrop), + + %% Add file+line information at the bottom + Bottom = + case erlang:get(?elixir_eval_env) of + #{file := File} -> + [{elixir_eval, '__FILE__', 1, + [{file, elixir_utils:characters_to_list(File)}, {line, erl_anno:line(Ann)}]}]; + + _ -> + [] + end, + + Custom = lists:reverse(Bottom ++ Reversed, DroppedCaller), + erlang:raise(Kind, Reason, Custom) + end. + +%% We need to check if we have dropped any frames. +%% If we have not dropped frames, then we need to drop one +%% at the end so we can put the elixir_eval frame in. If +%% we have more traces then depth, Erlang would discard +%% the whole stacktrace. +drop_common([H | T1], [H | T2], _ToDrop) -> drop_common(T1, T2, false); +drop_common([_ | T1], T2, ToDrop) -> drop_common(T1, T2, ToDrop); +drop_common([], [{?MODULE, _, _, _} | T2], _ToDrop) -> T2; +drop_common([], [_ | T2], true) -> T2; +drop_common([], T2, _) -> T2. + +%% Converts a quoted expression to Erlang abstract format + +quoted_to_erl(Quoted, E) -> + {_, ErlS} = elixir_erl_var:from_env(E), + ExS = elixir_env:env_to_ex(E), + quoted_to_erl(Quoted, ErlS, ExS, E). + +quoted_to_erl(Quoted, ErlS, ExS, Env) -> + {Expanded, NewExS, NewEnv} = + elixir_expand:expand(Quoted, ExS, Env), + {Erl, NewErlS} = elixir_erl_pass:translate(Expanded, erl_anno:new(?key(Env, line)), ErlS), + {Erl, NewErlS, NewExS, NewEnv}. + +%% Converts a given string (charlist) into quote expression + +string_to_tokens(String, StartLine, StartColumn, File, Opts) when is_integer(StartLine), is_binary(File) -> + case future_elixir_tokenizer:tokenize(String, StartLine, StartColumn, Opts) of + {ok, _Line, _Column, [], Tokens, Terminators} -> + {ok, lists:reverse(Tokens, Terminators)}; + {ok, _Line, _Column, Warnings, Tokens, Terminators} -> + (lists:keyfind(emit_warnings, 1, Opts) /= {emit_warnings, false}) andalso + [future_elixir_errors:erl_warn(L, File, M) || {L, M} <- lists:reverse(Warnings)], + {ok, lists:reverse(Tokens, Terminators)}; + {error, Info, _Rest, _Warnings, _SoFar} -> + {error, format_token_error(Info)} + end. + +format_token_error({Location, {ErrorPrefix, ErrorSuffix}, Token}) -> + {Location, {to_binary(ErrorPrefix), to_binary(ErrorSuffix)}, to_binary(Token)}; +format_token_error({Location, Error, Token}) -> + {Location, to_binary(Error), to_binary(Token)}. + +tokens_to_quoted(Tokens, WarningFile, Opts) -> + handle_parsing_opts(WarningFile, Opts), + + try future_elixir_parser:parse(Tokens) of + {ok, Forms} -> + {ok, Forms}; + {error, {Line, _, [{ErrorPrefix, ErrorSuffix}, Token]}} -> + {error, {parser_location(Line), {to_binary(ErrorPrefix), to_binary(ErrorSuffix)}, to_binary(Token)}}; + {error, {Line, _, [Error, Token]}} -> + {error, {parser_location(Line), to_binary(Error), to_binary(Token)}} + after + erase(elixir_parser_warning_file), + erase(elixir_parser_columns), + erase(elixir_token_metadata), + erase(elixir_literal_encoder) + end. + +parser_location({Line, Column, _}) -> + [{line, Line}, {column, Column}]; +parser_location(Meta) -> + Line = + case lists:keyfind(line, 1, Meta) of + {line, L} -> L; + false -> 0 + end, + + case lists:keyfind(column, 1, Meta) of + {column, C} -> [{line, Line}, {column, C}]; + false -> [{line, Line}] + end. + +'string_to_quoted!'(String, StartLine, StartColumn, File, Opts) -> + case string_to_tokens(String, StartLine, StartColumn, File, Opts) of + {ok, Tokens} -> + case tokens_to_quoted(Tokens, File, Opts) of + {ok, Forms} -> + Forms; + {error, {Meta, Error, Token}} -> + future_elixir_errors:parse_error(Meta, File, Error, Token, {String, StartLine, StartColumn}) + end; + {error, {Meta, Error, Token}} -> + future_elixir_errors:parse_error(Meta, File, Error, Token, {String, StartLine, StartColumn}) + end. + +to_binary(List) when is_list(List) -> elixir_utils:characters_to_binary(List); +to_binary(Atom) when is_atom(Atom) -> atom_to_binary(Atom). + +handle_parsing_opts(File, Opts) -> + WarningFile = + case lists:keyfind(emit_warnings, 1, Opts) of + {emit_warnings, false} -> nil; + _ -> File + end, + LiteralEncoder = + case lists:keyfind(literal_encoder, 1, Opts) of + {literal_encoder, Fun} -> Fun; + false -> false + end, + TokenMetadata = lists:keyfind(token_metadata, 1, Opts) == {token_metadata, true}, + Columns = lists:keyfind(columns, 1, Opts) == {columns, true}, + put(elixir_parser_warning_file, WarningFile), + put(elixir_parser_columns, Columns), + put(elixir_token_metadata, TokenMetadata), + put(elixir_literal_encoder, LiteralEncoder). diff --git a/forge/src/future_elixir.hrl b/forge/src/future_elixir.hrl new file mode 100644 index 00000000..66635295 --- /dev/null +++ b/forge/src/future_elixir.hrl @@ -0,0 +1,43 @@ +%% Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/src/elixir.hrl +-define(key(M, K), maps:get(K, M)). +-define(ann(Meta), elixir_erl:get_ann(Meta)). +-define(line(Meta), elixir_utils:get_line(Meta)). +-define(generated(Meta), elixir_utils:generated(Meta)). +-define(var_context, ?MODULE). +-define(remote(Ann, Module, Function, Args), {call, Ann, {remote, Ann, {atom, Ann, Module}, {atom, Ann, Function}}, Args}). + +-record(elixir_ex, { + caller=false, %% stores if __CALLER__ is allowed + %% TODO: Remove warn and everywhere it is set in v2.0 + prematch=raise, %% {Read, Counter, {bitsize, Original} | none} | warn | raise | pin + stacktrace=false, %% stores if __STACKTRACE__ is allowed + unused={#{}, 0}, %% a map of unused vars and a version counter for vars + runtime_modules=[], %% a list of modules defined in functions (runtime) + vars={#{}, false} %% a tuple with maps of read and optional write current vars +}). + +-record(elixir_erl, { + context=nil, %% can be match, guards or nil + extra=nil, %% extra information about the context, like pin_guard and map_key + caller=false, %% when true, it means caller was invoked + var_names=#{}, %% maps of defined variables and their alias + extra_guards=[], %% extra guards from args expansion + counter=#{}, %% a map counting the variables defined + expand_captures=false, %% a boolean to control if captures should be expanded + stacktrace=nil %% holds information about the stacktrace variable +}). + +-record(elixir_tokenizer, { + terminators=[], + unescape=true, + cursor_completion=false, + existing_atoms_only=false, + static_atoms_encoder=nil, + preserve_comments=nil, + identifier_tokenizer=elixir_tokenizer, + ascii_identifiers_only=true, + indentation=0, + column=1, + mismatch_hints=[], + warnings=[] +}). diff --git a/forge/src/future_elixir_errors.erl b/forge/src/future_elixir_errors.erl new file mode 100644 index 00000000..af0aadc7 --- /dev/null +++ b/forge/src/future_elixir_errors.erl @@ -0,0 +1,526 @@ +%% Copied from https://raw.githubusercontent.com/elixir-lang/elixir/31f5f126a6df0ceb4fe93d01545255380b74f4e8/lib/elixir/src/elixir_errors.erl +%% A bunch of helpers to help to deal with errors in Elixir source code. +%% This is not exposed in the Elixir language. +%% +%% Note that this is also called by the Erlang backend, so we also support +%% the line number to be none (as it may happen in some erlang errors). +-module(future_elixir_errors). +-export([compile_error/1, compile_error/3, parse_error/5]). +-export([function_error/4, module_error/4, file_error/4]). +-export([format_snippet/6]). +-export([erl_warn/3, file_warn/4]). +-export([prefix/1]). +-export([print_diagnostics/1, print_diagnostic/2, emit_diagnostic/6]). +-export([print_warning/3]). +-include("future_elixir.hrl"). +-type location() :: non_neg_integer() | {non_neg_integer(), non_neg_integer()}. + +%% Diagnostic API + +%% TODO: Remove me on Elixir v2.0. +%% Called by deprecated Kernel.ParallelCompiler.print_warning. +print_warning(Position, File, Message) -> + Output = format_snippet(warning, Position, File, Message, nil, #{}), + io:put_chars(standard_error, [Output, $\n, $\n]). + +read_snippet(nil, _Position) -> + nil; +read_snippet(<<"nofile">>, _Position) -> + nil; +read_snippet(File, Position) -> + LineNumber = extract_line(Position), + get_file_line(File, LineNumber). + +get_file_line(File, LineNumber) when is_integer(LineNumber), LineNumber > 0 -> + case file:open(File, [read, binary]) of + {ok, IoDevice} -> + Line = traverse_file_line(IoDevice, LineNumber), + ok = file:close(IoDevice), + Line; + {error, _} -> + nil + end; +get_file_line(_, _) -> nil. + +traverse_file_line(IoDevice, 1) -> + case file:read_line(IoDevice) of + {ok, Line} -> binary:replace(Line, <<"\n">>, <<>>); + _ -> nil + end; +traverse_file_line(IoDevice, N) -> + file:read_line(IoDevice), + traverse_file_line(IoDevice, N - 1). + +%% Used by Module.ParallelChecker. +print_diagnostics([Diagnostic | Others]) -> + #{file := File, position := Position, message := Message} = Diagnostic, + Snippet = read_snippet(File, Position), + Formatted = format_snippet(warning, Position, File, Message, Snippet, Diagnostic), + LineNumber = extract_line(Position), + LineDigits = get_line_number_digits(LineNumber, 1), + Padding = case Snippet of + nil -> 0; + _ -> max(4, LineDigits + 2) + end, + Locations = [["\n", n_spaces(Padding), "└─ ", 'Elixir.Exception':format_stacktrace_entry(ES)] || #{stacktrace := [ES]} <- Others], + io:put_chars(standard_error, [Formatted, Locations, $\n, $\n]). + +print_diagnostic(#{severity := S, message := M, position := P, file := F} = Diagnostic, ReadSnippet) -> + Snippet = + case ReadSnippet of + true -> read_snippet(F, P); + false -> nil + end, + + Output = format_snippet(S, P, F, M, Snippet, Diagnostic), + + MaybeStack = + case (F /= nil) orelse elixir_config:is_bootstrap() of + true -> []; + false -> [["\n ", 'Elixir.Exception':format_stacktrace_entry(E)] || E <- ?key(Diagnostic, stacktrace)] + end, + + io:put_chars(standard_error, [Output, MaybeStack, $\n, $\n]), + Diagnostic. + +emit_diagnostic(Severity, Position, File, Message, Stacktrace, Options) -> + ReadSnippet = proplists:get_value(read_snippet, Options, false), + + Span = case lists:keyfind(span, 1, Options) of + {span, {EndLine, EndCol}} -> {EndLine, EndCol}; + _ -> nil + end, + + Diagnostic = #{ + severity => Severity, + source => File, + file => File, + position => Position, + message => unicode:characters_to_binary(Message), + stacktrace => Stacktrace, + span => Span + }, + + case get(elixir_code_diagnostics) of + undefined -> + case get(elixir_compiler_info) of + undefined -> print_diagnostic(Diagnostic, ReadSnippet); + {CompilerPid, _} -> CompilerPid ! {diagnostic, Diagnostic, ReadSnippet} + end; + + {Tail, true} -> + put(elixir_code_diagnostics, {[print_diagnostic(Diagnostic, ReadSnippet) | Tail], true}); + + {Tail, false} -> + put(elixir_code_diagnostics, {[Diagnostic | Tail], false}) + end, + + ok. + +extract_line({L, _}) -> L; +extract_line(L) -> L. + +extract_column({_, C}) -> C; +extract_column(_) -> nil. + +%% Format snippets +%% "Snippet" here refers to the source code line where the diagnostic/error occurred + +format_snippet(Severity, _Position, nil, Message, nil, _Diagnostic) -> + Formatted = [prefix(Severity), " ", Message], + unicode:characters_to_binary(Formatted); + +format_snippet(Severity, Position, File, Message, nil, Diagnostic) -> + Location = location_format(Position, File, maps:get(stacktrace, Diagnostic, [])), + + Formatted = io_lib:format( + "~ts ~ts\n" + "└─ ~ts", + [prefix(Severity), Message, Location] + ), + + unicode:characters_to_binary(Formatted); + +format_snippet(Severity, Position, File, Message, Snippet, Diagnostic) -> + Column = extract_column(Position), + LineNumber = extract_line(Position), + LineDigits = get_line_number_digits(LineNumber, 1), + Spacing = n_spaces(max(2, LineDigits) + 1), + LineNumberSpacing = if LineDigits =:= 1 -> 1; true -> 0 end, + {FormattedLine, ColumnsTrimmed} = format_line(Snippet), + Location = location_format(Position, File, maps:get(stacktrace, Diagnostic, [])), + MessageDetail = format_detail(Diagnostic, Message), + + Highlight = + case Column of + nil -> + highlight_below_line(FormattedLine, Severity); + _ -> + Length = calculate_span_length({LineNumber, Column}, Diagnostic), + highlight_at_position(Column - ColumnsTrimmed, Severity, Length) + end, + + Formatted = io_lib:format( + " ~ts~ts ~ts\n" + " ~ts│\n" + " ~ts~p │ ~ts\n" + " ~ts│ ~ts\n" + " ~ts│\n" + " ~ts└─ ~ts", + [ + Spacing, prefix(Severity), format_message(MessageDetail, LineDigits, 2 + LineNumberSpacing), + Spacing, + n_spaces(LineNumberSpacing), LineNumber, FormattedLine, + Spacing, Highlight, + Spacing, + Spacing, Location + ]), + + unicode:characters_to_binary(Formatted). + +format_detail(#{details := #{typing_traces := _}}, Message) -> [Message | "\ntyping violation found at:"]; +format_detail(_, Message) -> Message. + +calculate_span_length({StartLine, StartCol}, #{span := {StartLine, EndCol}}) -> EndCol - StartCol; +calculate_span_length({StartLine, _}, #{span := {EndLine, _}}) when EndLine > StartLine -> 1; +calculate_span_length({_, _}, #{}) -> 1. + +format_line(Line) -> + case trim_line(Line, 0) of + {Trimmed, SpacesMatched} when SpacesMatched >= 27 -> + ColumnsTrimmed = SpacesMatched - 22, + {["...", n_spaces(19), Trimmed], ColumnsTrimmed}; + + {_, _} -> + {Line, 0} + end. + +trim_line(<<$\s, Rest/binary>>, Count) -> trim_line(Rest, Count + 1); +trim_line(<<$\t, Rest/binary>>, Count) -> trim_line(Rest, Count + 8); +trim_line(Rest, Count) -> {Rest, Count}. + +format_message(Message, NDigits, PaddingSize) -> + Padding = list_to_binary([$\n, n_spaces(NDigits + PaddingSize)]), + Bin = unicode:characters_to_binary(Message), + pad_line(binary:split(Bin, <<"\n">>, [global]), Padding). + +pad_line([Last], _Padding) -> [Last]; +pad_line([First, <<"">> | Rest], Padding) -> [First, "\n" | pad_line([<<"">> | Rest], Padding)]; +pad_line([First | Rest], Padding) -> [First, Padding | pad_line(Rest, Padding)]. + +highlight_at_position(Column, Severity, Length) -> + Spacing = n_spaces(max(Column - 1, 0)), + case Severity of + warning -> highlight([Spacing, lists:duplicate(Length, $~)], warning); + error -> highlight([Spacing, lists:duplicate(Length, $^)], error) + end. + +highlight_below_line(Line, Severity) -> + % Don't highlight leading whitespaces in line + {_, SpacesMatched} = trim_line(Line, 0), + + Length = string:length(Line), + Highlight = case Severity of + warning -> highlight(lists:duplicate(Length - SpacesMatched, $~), warning); + error -> highlight(lists:duplicate(Length - SpacesMatched, $^), error) + end, + + [n_spaces(SpacesMatched), Highlight]. + +get_line_number_digits(Number, Acc) when Number < 10 -> Acc; +get_line_number_digits(Number, Acc) -> + get_line_number_digits(Number div 10, Acc + 1). + +n_spaces(N) -> lists:duplicate(N, " "). + +%% Compilation error/warn handling. + +%% Low-level warning, should be used only from Erlang passes. +-spec erl_warn(location() | none, unicode:chardata(), unicode:chardata()) -> ok. +erl_warn(none, File, Warning) -> + erl_warn(0, File, Warning); +erl_warn(Location, File, Warning) when is_binary(File) -> + emit_diagnostic(warning, Location, File, Warning, [], [{read_snippet, true}]). + +-spec file_warn(list(), binary() | #{file := binary(), _ => _}, module(), any()) -> ok. +file_warn(Meta, File, Module, Desc) when is_list(Meta), is_binary(File) -> + file_warn(Meta, #{file => File}, Module, Desc); +file_warn(Meta, E, Module, Desc) when is_list(Meta) -> + % Skip warnings during bootstrap, they will be reported during recompilation + case elixir_config:is_bootstrap() of + true -> ok; + false -> + {EnvPosition, EnvFile, EnvStacktrace} = env_format(Meta, E), + Message = Module:format_error(Desc), + emit_diagnostic(warning, EnvPosition, EnvFile, Message, EnvStacktrace, [{read_snippet, true} | Meta]) + end. + +-spec file_error(list(), binary() | #{file := binary(), _ => _}, module(), any()) -> no_return(). +file_error(Meta, File, Module, Desc) when is_list(Meta), is_binary(File) -> + file_error(Meta, #{file => File}, Module, Desc); +file_error(Meta, Env, Module, Desc) when is_list(Meta) -> + print_error(Meta, Env, Module, Desc), + compile_error(Env). + +%% A module error is one where it can continue if there is a module +%% being compiled. If there is no module, it is a regular file_error. +-spec module_error(list(), #{file := binary(), module => module() | nil, _ => _}, module(), any()) -> ok. +module_error(Meta, #{module := EnvModule} = Env, Module, Desc) when EnvModule /= nil -> + print_error(Meta, Env, Module, Desc), + case elixir_module:taint(EnvModule) of + true -> ok; + false -> compile_error(Env) + end; +module_error(Meta, Env, Module, Desc) -> + file_error(Meta, Env, Module, Desc). + +%% A function error is one where it can continue if there is a function +%% being compiled. If there is no function, it is falls back to file_error. +-spec function_error(list(), #{file := binary(), function => {term(), term()} | nil, _ => _}, module(), any()) -> ok. +function_error(Meta, #{function := {_, _}} = Env, Module, Desc) -> + module_error(Meta, Env, Module, Desc); +function_error(Meta, Env, Module, Desc) -> + file_error(Meta, Env, Module, Desc). + +print_error(Meta, Env, Module, Desc) -> + {EnvPosition, EnvFile, EnvStacktrace} = env_format(Meta, Env), + Message = Module:format_error(Desc), + emit_diagnostic(error, EnvPosition, EnvFile, Message, EnvStacktrace, [{read_snippet, true} | Meta]), + ok. + +%% Compilation error. + +-spec compile_error(#{file := binary(), _ => _}) -> no_return(). +%% We check for the lexical tracker because pry() inside a module +%% will have the environment but not a tracker. +compile_error(#{module := Module, file := File, lexical_tracker := LT}) when Module /= nil, LT /= nil -> + Inspected = elixir_aliases:inspect(Module), + Message = io_lib:format("cannot compile module ~ts (errors have been logged)", [Inspected]), + compile_error([], File, Message); +compile_error(#{file := File}) -> + compile_error([], File, "cannot compile file (errors have been logged)"). + +-spec compile_error(list(), binary(), binary() | unicode:charlist()) -> no_return(). +compile_error(Meta, File, Message) when is_binary(Message) -> + {File, Position} = meta_location(Meta, File), + raise('Elixir.CompileError', Message, [{file, File} | Position]); +compile_error(Meta, File, Message) when is_list(Message) -> + {File, Position} = meta_location(Meta, File), + raise('Elixir.CompileError', elixir_utils:characters_to_binary(Message), [{file, File} | Position]). + +%% Tokenization parsing/errors. + +-spec parse_error(elixir:keyword(), binary() | {binary(), binary()}, + binary(), binary(), {unicode:charlist(), integer(), integer()}) -> no_return(). +parse_error(Location, File, Error, <<>>, Input) -> + Message = case Error of + <<"syntax error before: ">> -> <<"syntax error: expression is incomplete">>; + _ -> <> + end, + + raise_snippet(Location, File, Input, 'Elixir.TokenMissingError', Message); + +%% Show a nicer message for end of line +parse_error(Location, File, <<"syntax error before: ">>, <<"eol">>, Input) -> + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', + <<"unexpectedly reached end of line. The current expression is invalid or incomplete">>); + +%% Show a nicer message for keywords pt1 (Erlang keywords show up wrapped in single quotes) +parse_error(Location, File, <<"syntax error before: ">>, Keyword, Input) + when Keyword == <<"'not'">>; + Keyword == <<"'and'">>; + Keyword == <<"'or'">>; + Keyword == <<"'when'">>; + Keyword == <<"'after'">>; + Keyword == <<"'catch'">>; + Keyword == <<"'end'">> -> + raise_reserved(Location, File, Input, binary_part(Keyword, 1, byte_size(Keyword) - 2)); + +%% Show a nicer message for keywords pt2 (Elixir keywords show up as is) +parse_error(Location, File, <<"syntax error before: ">>, Keyword, Input) + when Keyword == <<"fn">>; + Keyword == <<"else">>; + Keyword == <<"rescue">>; + Keyword == <<"true">>; + Keyword == <<"false">>; + Keyword == <<"nil">>; + Keyword == <<"in">> -> + raise_reserved(Location, File, Input, Keyword); + +%% Produce a human-readable message for errors before a sigil +parse_error(Location, File, <<"syntax error before: ">>, <<"{sigil,", _Rest/binary>> = Full, Input) -> + {ok, {sigil, _, Atom, [Content | _], _, _, _}} = parse_erl_term(Full), + Content2 = case is_binary(Content) of + true -> Content; + false -> <<>> + end, + + % :static_atoms_encoder might encode :sigil_ atoms as arbitrary terms + MaybeSigil = case is_atom(Atom) of + true -> case atom_to_binary(Atom) of + <<"sigil_", Chars/binary>> -> <<"\~", Chars/binary, " ">>; + _ -> <<>> + end; + false -> <<>> + end, + + Message = <<"syntax error before: sigil ", MaybeSigil/binary, "starting with content '", Content2/binary, "'">>, + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message); + +%% Binaries (and interpolation) are wrapped in [<<...>>] +parse_error(Location, File, Error, <<"[", _/binary>> = Full, Input) when is_binary(Error) -> + Term = case parse_erl_term(Full) of + {ok, [H | _]} when is_binary(H) -> <<$", H/binary, $">>; + _ -> <<$">> + end, + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', <>); + +%% Given a string prefix and suffix to insert the token inside the error message rather than append it +parse_error(Location, File, {ErrorPrefix, ErrorSuffix}, Token, Input) when is_binary(ErrorPrefix), is_binary(ErrorSuffix), is_binary(Token) -> + Message = <>, + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message); + +%% Misplaced char tokens (for example, {char, _, 97}) are translated by Erlang into +%% the char literal (i.e., the token in the previous example becomes $a), +%% because {char, _, _} is a valid Erlang token for an Erlang char literal. We +%% want to represent that token as ?a in the error, according to the Elixir +%% syntax. +parse_error(Location, File, <<"syntax error before: ">>, <<$$, Char/binary>>, Input) -> + Message = <<"syntax error before: ?", Char/binary>>, + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message); + +%% Everything else is fine as is +parse_error(Location, File, Error, Token, Input) when is_binary(Error), is_binary(Token) -> + Message = <>, + case lists:keytake(error_type, 1, Location) of + {value, {error_type, mismatched_delimiter}, Loc} -> + raise_snippet(Loc, File, Input, 'Elixir.MismatchedDelimiterError', Message); + _ -> + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', Message) + end. + +parse_erl_term(Term) -> + case erl_scan:string(binary_to_list(Term)) of + {ok, Tokens, _} -> + case erl_parse:parse_term(Tokens ++ [{dot, 1}]) of + {ok, Parsed} -> {ok, Parsed}; + _ -> error + end; + _ -> error + end. + +raise_reserved(Location, File, Input, Keyword) -> + raise_snippet(Location, File, Input, 'Elixir.SyntaxError', + <<"syntax error before: ", Keyword/binary, ". \"", Keyword/binary, "\" is a " + "reserved word in Elixir and therefore its usage is limited. For instance, " + "it can't be used as a variable or be defined nor invoked as a regular function">>). + +raise_snippet(Location, File, Input, Kind, Message) when is_binary(File) -> + Snippet = cut_snippet(Location, Input), + raise(Kind, Message, [{file, File}, {snippet, Snippet} | Location]). + +cut_snippet(Location, Input) -> + case lists:keyfind(column, 1, Location) of + {column, _} -> + {line, Line} = lists:keyfind(line, 1, Location), + + case lists:keyfind(end_line, 1, Location) of + {end_line, EndLine} -> + cut_snippet(Input, Line, EndLine - Line + 1); + + false -> + Snippet = cut_snippet(Input, Line, 1), + case string:trim(Snippet, leading) of + <<>> -> nil; + _ -> Snippet + end + end; + + false -> + nil + end. + +cut_snippet({InputString, StartLine, StartColumn}, Line, Span) -> + %% In case the code is indented, we need to add the indentation back + %% for the snippets to match the reported columns. + Indent = binary:copy(<<" ">>, StartColumn - 1), + Lines = string:split(InputString, "\n", all), + [Head | Tail] = lists:nthtail(Line - StartLine, Lines), + IndentedTail = indent_n(Tail, Span - 1, <<"\n", Indent/binary>>), + elixir_utils:characters_to_binary([Indent, Head, IndentedTail]). + +indent_n([], _Count, _Indent) -> []; +indent_n(_Lines, 0, _Indent) -> []; +indent_n([H | T], Count, Indent) -> [Indent, H | indent_n(T, Count - 1, Indent)]. + +%% Helpers + +prefix(warning) -> highlight(<<"warning:">>, warning); +prefix(error) -> highlight(<<"error:">>, error); +prefix(hint) -> highlight(<<"hint:">>, hint). + +highlight(Message, Severity) -> + case {Severity, application:get_env(elixir, ansi_enabled, false)} of + {warning, true} -> yellow(Message); + {error, true} -> red(Message); + {hint, true} -> blue(Message); + _ -> Message + end. + +yellow(Msg) -> ["\e[33m", Msg, "\e[0m"]. +blue(Msg) -> ["\e[34m", Msg, "\e[0m"]. +red(Msg) -> ["\e[31m", Msg, "\e[0m"]. + +env_format(Meta, #{file := EnvFile} = E) -> + {File, Position} = meta_location(Meta, EnvFile), + Line = ?line(Position), + + Stacktrace = + case E of + #{function := {Name, Arity}, module := Module} -> + [{Module, Name, Arity, [{file, elixir_utils:relative_to_cwd(File)} | Position ]}]; + #{module := Module} when Module /= nil -> + [{Module, '__MODULE__', 0, [{file, elixir_utils:relative_to_cwd(File)} | Position]}]; + #{} -> + [] + end, + + case lists:keyfind(column, 1, Position) of + {column, Column} -> {{Line, Column}, File, Stacktrace}; + _ -> {Line, File, Stacktrace} + end. + +%% We prefer the stacktrace, if available, as it also contains module/function. +location_format(_Position, _File, [E | _]) -> + 'Elixir.Exception':format_stacktrace_entry(E); +location_format(Position, File, []) -> + file_format(Position, File). + +file_format({0, _Column}, File) -> + elixir_utils:relative_to_cwd(File); +file_format({Line, nil}, File) -> + file_format(Line, File); +file_format({Line, Column}, File) -> + io_lib:format("~ts:~w:~w", [elixir_utils:relative_to_cwd(File), Line, Column]); +file_format(0, File) -> + elixir_utils:relative_to_cwd(File); +file_format(Line, File) -> + io_lib:format("~ts:~w", [elixir_utils:relative_to_cwd(File), Line]). + +meta_location(Meta, File) -> + case elixir_utils:meta_keep(Meta) of + {F, L} -> {F, [{line, L}]}; + nil -> {File, maybe_add_col([{line, ?line(Meta)}], Meta)} + end. + +maybe_add_col(Position, Meta) -> + case lists:keyfind(column, 1, Meta) of + {column, Col} when is_integer(Col) -> [{column, Col} | Position]; + false -> Position + end. + +raise(Kind, Message, Opts) when is_binary(Message) -> + Stacktrace = try throw(ok) catch _:_:Stack -> Stack end, + Exception = Kind:exception([{description, Message} | Opts]), + erlang:raise(error, Exception, tl(Stacktrace)). + diff --git a/forge/src/future_elixir_interpolation.erl b/forge/src/future_elixir_interpolation.erl new file mode 100644 index 00000000..1f62eb6f --- /dev/null +++ b/forge/src/future_elixir_interpolation.erl @@ -0,0 +1,295 @@ +% Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/src/elixir_interpolation.erl +% Handle string and string-like interpolations. +-module(future_elixir_interpolation). +-export([extract/6, unescape_string/1, unescape_string/2, +unescape_tokens/1, unescape_map/1]). +-include("future_elixir.hrl"). +-include("future_elixir_tokenizer.hrl"). + +%% Extract string interpolations + +extract(Line, Column, Scope, Interpol, String, Last) -> + extract(String, [], [], Line, Column, Scope, Interpol, Last). + +%% Terminators + +extract([], _Buffer, _Output, Line, Column, #elixir_tokenizer{cursor_completion=false}, _Interpol, Last) -> + {error, {string, Line, Column, io_lib:format("missing terminator: ~ts", [[Last]]), []}}; + +extract([], Buffer, Output, Line, Column, Scope, _Interpol, _Last) -> + finish_extraction([], Buffer, Output, Line, Column, Scope); + +extract([Last | Rest], Buffer, Output, Line, Column, Scope, _Interpol, Last) -> + finish_extraction(Rest, Buffer, Output, Line, Column + 1, Scope); + +%% Going through the string + +extract([$\\, $\r, $\n | Rest], Buffer, Output, Line, _Column, Scope, Interpol, Last) -> + extract_nl(Rest, [$\n, $\r, $\\ | Buffer], Output, Line, Scope, Interpol, Last); + +extract([$\\, $\n | Rest], Buffer, Output, Line, _Column, Scope, Interpol, Last) -> + extract_nl(Rest, [$\n, $\\ | Buffer], Output, Line, Scope, Interpol, Last); + +extract([$\n | Rest], Buffer, Output, Line, _Column, Scope, Interpol, Last) -> + extract_nl(Rest, [$\n | Buffer], Output, Line, Scope, Interpol, Last); + +extract([$\\, Last | Rest], Buffer, Output, Line, Column, Scope, Interpol, Last) -> + NewScope = + %% TODO: Remove this on Elixir v2.0 + case Interpol of + true -> + Scope; + false -> + Msg = "using \\~ts to escape the closing of an uppercase sigil is deprecated, please use another delimiter or a lowercase sigil instead", + prepend_warning(Line, Column, io_lib:format(Msg, [[Last]]), Scope) + end, + + extract(Rest, [Last | Buffer], Output, Line, Column+2, NewScope, Interpol, Last); + +extract([$\\, Last, Last, Last | Rest], Buffer, Output, Line, Column, Scope, Interpol, [Last, Last, Last] = All) -> + extract(Rest, [Last, Last, Last | Buffer], Output, Line, Column+4, Scope, Interpol, All); + +extract([$\\, $#, ${ | Rest], Buffer, Output, Line, Column, Scope, true, Last) -> + extract(Rest, [${, $#, $\\ | Buffer], Output, Line, Column+3, Scope, true, Last); + +extract([$#, ${ | Rest], Buffer, Output, Line, Column, Scope, true, Last) -> + Output1 = build_string(Buffer, Output), + case future_elixir_tokenizer:tokenize(Rest, Line, Column + 2, Scope#elixir_tokenizer{terminators=[]}) of + {error, {Location, _, "}"}, [$} | NewRest], Warnings, Tokens} -> + NewScope = Scope#elixir_tokenizer{warnings=Warnings}, + {line, EndLine} = lists:keyfind(line, 1, Location), + {column, EndColumn} = lists:keyfind(column, 1, Location), + Output2 = build_interpol(Line, Column, EndLine, EndColumn, lists:reverse(Tokens), Output1), + extract(NewRest, [], Output2, EndLine, EndColumn + 1, NewScope, true, Last); + {error, Reason, _, _, _} -> + {error, Reason}; + {ok, EndLine, EndColumn, Warnings, Tokens, Terminators} when Scope#elixir_tokenizer.cursor_completion /= false -> + NewScope = Scope#elixir_tokenizer{warnings=Warnings, cursor_completion=noprune}, + Output2 = build_interpol(Line, Column, EndLine, EndColumn, lists:reverse(Tokens, Terminators), Output1), + extract([], [], Output2, EndLine, EndColumn, NewScope, true, Last); + {ok, _, _, _, _, _} -> + {error, {string, Line, Column, "missing interpolation terminator: \"}\"", []}} + end; + +extract([$\\ | Rest], Buffer, Output, Line, Column, Scope, Interpol, Last) -> + extract_char(Rest, [$\\ | Buffer], Output, Line, Column + 1, Scope, Interpol, Last); + +%% Catch all clause + +extract([Char1, Char2 | Rest], Buffer, Output, Line, Column, Scope, Interpol, Last) + when Char1 =< 255, Char2 =< 255 -> + extract([Char2 | Rest], [Char1 | Buffer], Output, Line, Column + 1, Scope, Interpol, Last); + +extract(Rest, Buffer, Output, Line, Column, Scope, Interpol, Last) -> + extract_char(Rest, Buffer, Output, Line, Column, Scope, Interpol, Last). + +extract_char(Rest, Buffer, Output, Line, Column, Scope, Interpol, Last) -> + case unicode_util:gc(Rest) of + [Char | _] when ?bidi(Char) -> + Token = io_lib:format("\\u~4.16.0B", [Char]), + Pre = "invalid bidirectional formatting character in string: ", + Pos = io_lib:format(". If you want to use such character, use it in its escaped ~ts form instead", [Token]), + {error, {?LOC(Line, Column), {Pre, Pos}, Token}}; + + [Char | NewRest] -> + extract(NewRest, [Char | Buffer], Output, Line, Column + 1, Scope, Interpol, Last); + + [] -> + extract([], Buffer, Output, Line, Column, Scope, Interpol, Last) + end. + +%% Handle newlines. Heredocs require special attention + +extract_nl(Rest, Buffer, Output, Line, Scope, Interpol, [H,H,H] = Last) -> + case strip_horizontal_space(Rest, Buffer, 1) of + {[H,H,H|NewRest], _NewBuffer, Column} -> + finish_extraction(NewRest, Buffer, Output, Line + 1, Column + 3, Scope); + {NewRest, NewBuffer, Column} -> + extract(NewRest, NewBuffer, Output, Line + 1, Column, Scope, Interpol, Last) + end; +extract_nl(Rest, Buffer, Output, Line, Scope, Interpol, Last) -> + extract(Rest, Buffer, Output, Line + 1, Scope#elixir_tokenizer.column, Scope, Interpol, Last). + +strip_horizontal_space([H | T], Buffer, Counter) when H =:= $\s; H =:= $\t -> + strip_horizontal_space(T, [H | Buffer], Counter + 1); +strip_horizontal_space(T, Buffer, Counter) -> + {T, Buffer, Counter}. + +%% Unescape a series of tokens as returned by extract. + +unescape_tokens(Tokens) -> + try [unescape_token(Token, fun unescape_map/1) || Token <- Tokens] of + Unescaped -> {ok, Unescaped} + catch + {error, _Reason, _Token} = Error -> Error + end. + +unescape_token(Token, Map) when is_list(Token) -> + unescape_chars(elixir_utils:characters_to_binary(Token), Map); +unescape_token(Token, Map) when is_binary(Token) -> + unescape_chars(Token, Map); +unescape_token(Other, _Map) -> + Other. + +% Unescape string. This is called by Elixir. Wrapped by convenience. + +unescape_string(String) -> + unescape_string(String, fun unescape_map/1). + +unescape_string(String, Map) -> + try + unescape_chars(String, Map) + catch + {error, Reason, _} -> + Message = elixir_utils:characters_to_binary(Reason), + error('Elixir.ArgumentError':exception([{message, Message}])) + end. + +% Unescape chars. For instance, "\" "n" (two chars) needs to be converted to "\n" (one char). + +unescape_chars(String, Map) -> + unescape_chars(String, Map, <<>>). + +unescape_chars(<<$\\, $x, Rest/binary>>, Map, Acc) -> + case Map(hex) of + true -> unescape_hex(Rest, Map, Acc); + false -> unescape_chars(Rest, Map, <>) + end; + +unescape_chars(<<$\\, $u, Rest/binary>>, Map, Acc) -> + case Map(unicode) of + true -> unescape_unicode(Rest, Map, Acc); + false -> unescape_chars(Rest, Map, <>) + end; + +unescape_chars(<<$\\, $\n, Rest/binary>>, Map, Acc) -> + case Map(newline) of + true -> unescape_chars(Rest, Map, Acc); + false -> unescape_chars(Rest, Map, <>) + end; + +unescape_chars(<<$\\, $\r, $\n, Rest/binary>>, Map, Acc) -> + case Map(newline) of + true -> unescape_chars(Rest, Map, Acc); + false -> unescape_chars(Rest, Map, <>) + end; + +unescape_chars(<<$\\, Escaped, Rest/binary>>, Map, Acc) -> + case Map(Escaped) of + false -> unescape_chars(Rest, Map, <>); + Other -> unescape_chars(Rest, Map, <>) + end; + +unescape_chars(<>, Map, Acc) -> + unescape_chars(Rest, Map, <>); + +unescape_chars(<<>>, _Map, Acc) -> Acc. + +% Unescape Helpers + +unescape_hex(<>, Map, Acc) when ?is_hex(A), ?is_hex(B) -> + Bytes = list_to_integer([A, B], 16), + unescape_chars(Rest, Map, <>); + +%% TODO: Remove deprecated sequences on v2.0 + +unescape_hex(<>, Map, Acc) when ?is_hex(A) -> + io:format(standard_error, "warning: \\xH inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A], Acc, 16); + +unescape_hex(<<${, A, $}, Rest/binary>>, Map, Acc) when ?is_hex(A) -> + io:format(standard_error, "warning: \\x{H*} inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A], Acc, 16); + +unescape_hex(<<${, A, B, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B) -> + io:format(standard_error, "warning: \\x{H*} inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A, B], Acc, 16); + +unescape_hex(<<${, A, B, C, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C) -> + io:format(standard_error, "warning: \\x{H*} inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A, B, C], Acc, 16); + +unescape_hex(<<${, A, B, C, D, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) -> + io:format(standard_error, "warning: \\x{H*} inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A, B, C, D], Acc, 16); + +unescape_hex(<<${, A, B, C, D, E, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E) -> + io:format(standard_error, "warning: \\x{H*} inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A, B, C, D, E], Acc, 16); + +unescape_hex(<<${, A, B, C, D, E, F, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E), ?is_hex(F) -> + io:format(standard_error, "warning: \\x{H*} inside strings/sigils/chars is deprecated, please use \\xHH (byte) or \\uHHHH (code point) instead~n", []), + append_codepoint(Rest, Map, [A, B, C, D, E, F], Acc, 16); + +unescape_hex(<<_/binary>>, _Map, _Acc) -> + throw({error, "invalid hex escape character, expected \\xHH where H is a hexadecimal digit", "\\x"}). + +%% Finish deprecated sequences + +unescape_unicode(<>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) -> + append_codepoint(Rest, Map, [A, B, C, D], Acc, 16); + +unescape_unicode(<<${, A, $}, Rest/binary>>, Map, Acc) when ?is_hex(A) -> + append_codepoint(Rest, Map, [A], Acc, 16); + +unescape_unicode(<<${, A, B, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B) -> + append_codepoint(Rest, Map, [A, B], Acc, 16); + +unescape_unicode(<<${, A, B, C, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C) -> + append_codepoint(Rest, Map, [A, B, C], Acc, 16); + +unescape_unicode(<<${, A, B, C, D, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D) -> + append_codepoint(Rest, Map, [A, B, C, D], Acc, 16); + +unescape_unicode(<<${, A, B, C, D, E, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E) -> + append_codepoint(Rest, Map, [A, B, C, D, E], Acc, 16); + +unescape_unicode(<<${, A, B, C, D, E, F, $}, Rest/binary>>, Map, Acc) when ?is_hex(A), ?is_hex(B), ?is_hex(C), ?is_hex(D), ?is_hex(E), ?is_hex(F) -> + append_codepoint(Rest, Map, [A, B, C, D, E, F], Acc, 16); + +unescape_unicode(<<_/binary>>, _Map, _Acc) -> + throw({error, "invalid Unicode escape character, expected \\uHHHH or \\u{H*} where H is a hexadecimal digit", "\\u"}). + +append_codepoint(Rest, Map, List, Acc, Base) -> + Codepoint = list_to_integer(List, Base), + try <> of + Binary -> unescape_chars(Rest, Map, Binary) + catch + error:badarg -> + throw({error, "invalid or reserved Unicode code point \\u{" ++ List ++ "}", "\\u"}) + end. + +unescape_map(newline) -> true; +unescape_map(unicode) -> true; +unescape_map(hex) -> true; +unescape_map($0) -> 0; +unescape_map($a) -> 7; +unescape_map($b) -> $\b; +unescape_map($d) -> $\d; +unescape_map($e) -> $\e; +unescape_map($f) -> $\f; +unescape_map($n) -> $\n; +unescape_map($r) -> $\r; +unescape_map($s) -> $\s; +unescape_map($t) -> $\t; +unescape_map($v) -> $\v; +unescape_map(E) -> E. + +% Extract Helpers + +finish_extraction(Remaining, Buffer, Output, Line, Column, Scope) -> + Final = case build_string(Buffer, Output) of + [] -> [[]]; + F -> F + end, + + {Line, Column, lists:reverse(Final), Remaining, Scope}. + +build_string([], Output) -> Output; +build_string(Buffer, Output) -> [lists:reverse(Buffer) | Output]. + +build_interpol(Line, Column, EndLine, EndColumn, Buffer, Output) -> + [{{Line, Column, nil}, {EndLine, EndColumn, nil}, Buffer} | Output]. + +prepend_warning(Line, Column, Msg, #elixir_tokenizer{warnings=Warnings} = Scope) -> + Scope#elixir_tokenizer{warnings = [{{Line, Column}, Msg} | Warnings]}. diff --git a/forge/src/future_elixir_parser.erl b/forge/src/future_elixir_parser.erl new file mode 100644 index 00000000..3a4e2c24 --- /dev/null +++ b/forge/src/future_elixir_parser.erl @@ -0,0 +1,33586 @@ +-file("src/future_elixir_parser.yrl", 0). +-module(future_elixir_parser). +-file("src/future_elixir_parser.erl", 3). +-export([parse/1, parse_and_scan/1, format_error/1]). +-file("src/future_elixir_parser.yrl", 650). + +-define(columns(), get(elixir_parser_columns)). +-define(token_metadata(), get(elixir_token_metadata)). + +-define(id(Token), element(1, Token)). +-define(location(Token), element(2, Token)). +-define(exprs(Token), element(3, Token)). +-define(meta(Node), element(2, Node)). +-define(rearrange_uop(Op), (Op == 'not' orelse Op == '!')). + +-compile({inline, meta_from_token/1, meta_from_location/1, is_eol/1}). +-import(lists, [reverse/1, reverse/2]). + +meta_from_token(Token) -> + meta_from_location(?location(Token)). + +meta_from_location({Line, Column, _}) -> + case ?columns() of + true -> [{line, Line}, {column, Column}]; + false -> [{line, Line}] + end. + +do_end_meta(Do, End) -> + case ?token_metadata() of + true -> + [{do, meta_from_location(?location(Do))}, {'end', meta_from_location(?location(End))}]; + false -> + [] + end. + +meta_from_token_with_closing(Begin, End) -> + case ?token_metadata() of + true -> + [{closing, meta_from_location(?location(End))} | meta_from_token(Begin)]; + false -> + meta_from_token(Begin) + end. + +append_non_empty(Left, []) -> Left; +append_non_empty(Left, Right) -> Left ++ Right. + +%% Handle metadata in literals + +handle_literal(Literal, Token) -> + handle_literal(Literal, Token, []). + +handle_literal(Literal, Token, ExtraMeta) -> + case get(elixir_literal_encoder) of + false -> + Literal; + + Fun -> + Meta = ExtraMeta ++ meta_from_token(Token), + case Fun(Literal, Meta) of + {ok, EncodedLiteral} -> + EncodedLiteral; + {error, Reason} -> + return_error(?location(Token), elixir_utils:characters_to_list(Reason) ++ [": "], "literal") + end + end. + +handle_number(Number, Token, Original) -> + case ?token_metadata() of + true -> handle_literal(Number, Token, [{token, elixir_utils:characters_to_binary(Original)}]); + false -> handle_literal(Number, Token, []) + end. + +number_value({_, {_, _, Value}, _}) -> + Value. + +%% Operators + +build_op(Left, {Op, Right}) -> + build_op(Left, Op, Right). + +build_op(AST, {_Kind, Location, '//'}, Right) -> + case AST of + {'..', Meta, [Left, Middle]} -> + {'..//', Meta, [Left, Middle, Right]}; + + _ -> + return_error(Location, "the range step operator (//) must immediately follow the range definition operator (..), for example: 1..9//2. If you wanted to define a default argument, use (\\\\) instead. Syntax error before: ", "'//'") + end; + +build_op({UOp, _, [Left]}, {_Kind, {Line, Column, _} = Location, 'in'}, Right) when ?rearrange_uop(UOp) -> + %% TODO: Remove "not left in right" rearrangement on v2.0 + warn({Line, Column}, "\"not expr1 in expr2\" is deprecated, use \"expr1 not in expr2\" instead"), + Meta = meta_from_location(Location), + {UOp, Meta, [{'in', Meta, [Left, Right]}]}; + +build_op(Left, {_Kind, Location, 'not in'}, Right) -> + Meta = meta_from_location(Location), + {'not', Meta, [{'in', Meta, [Left, Right]}]}; + +build_op(Left, {_Kind, Location, Op}, Right) -> + {Op, newlines_op(Location) ++ meta_from_location(Location), [Left, Right]}. + +build_unary_op({_Kind, {Line, Column, _}, '//'}, Expr) -> + {Outer, Inner} = + case ?columns() of + true -> {[{column, Column+1}], [{column, Column}]}; + false -> {[], []} + end, + {'/', [{line, Line} | Outer], [{'/', [{line, Line} | Inner], nil}, Expr]}; + +build_unary_op({_Kind, Location, Op}, Expr) -> + {Op, meta_from_location(Location), [Expr]}. + +build_nullary_op({_Kind, Location, Op}) -> + {Op, meta_from_location(Location), []}. + +build_list(Left, Args, Right) -> + {handle_literal(Args, Left, newlines_pair(Left, Right)), ?location(Left)}. + +build_tuple(Left, [Arg1, Arg2], Right) -> + handle_literal({Arg1, Arg2}, Left, newlines_pair(Left, Right)); +build_tuple(Left, Args, Right) -> + {'{}', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}. + +build_bit(Left, Args, Right) -> + {'<<>>', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}. + +build_map(Left, Args, Right) -> + {'%{}', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}. + +build_map_update(Left, {Pipe, Struct, Map}, Right, Extra) -> + Op = build_op(Struct, Pipe, append_non_empty(Map, Extra)), + {'%{}', newlines_pair(Left, Right) ++ meta_from_token(Left), [Op]}. + +adjust_map_column(Map) -> + case ?columns() of + true -> + {'%{}', Meta, Pairs} = Map, + UpdatedMeta = [{Key, if Key =:= column -> Value - 1; true -> Value end} || + {Key, Value} <- Meta], + {'%{}', UpdatedMeta, Pairs}; + false -> + Map + end. + +%% Blocks + +build_block(Exprs) -> build_block(Exprs, []). + +build_block([{unquote_splicing, _, [_]}]=Exprs, Meta) -> + {'__block__', Meta, Exprs}; +build_block([Expr], _Meta) -> + Expr; +build_block(Exprs, Meta) -> + {'__block__', Meta, Exprs}. + +%% Newlines + +newlines_pair(Left, Right) -> + case ?token_metadata() of + true -> + newlines(?location(Left), [{closing, meta_from_location(?location(Right))}]); + false -> + [] + end. + +newlines_op(Location) -> + case ?token_metadata() of + true -> newlines(Location, []); + false -> [] + end. + +next_is_eol(Token, {_, {_, _, Count}}) -> + {Line, Column, _} = ?location(Token), + setelement(2, Token, {Line, Column, Count}). + +newlines({_, _, Count}, Meta) when is_integer(Count) and (Count > 0) -> + [{newlines, Count} | Meta]; +newlines(_, Meta) -> + Meta. + +annotate_eoe(Token, Stack) -> + case ?token_metadata() of + true -> + case {Token, Stack} of + {{_, Location}, [{'->', StabMeta, [StabArgs, {Left, Meta, Right}]} | Rest]} when is_list(Meta) -> + [{'->', StabMeta, [StabArgs, {Left, [{end_of_expression, end_of_expression(Location)} | Meta], Right}]} | Rest]; + + {{_, Location}, [{Left, Meta, Right} | Rest]} when is_list(Meta), Left =/= '->' -> + [{Left, [{end_of_expression, end_of_expression(Location)} | Meta], Right} | Rest]; + + _ -> + Stack + end; + false -> + Stack + end. + +end_of_expression({_, _, Count} = Location) when is_integer(Count) -> + [{newlines, Count} | meta_from_location(Location)]; +end_of_expression(Location) -> + meta_from_location(Location). + +%% Dots + +build_alias({'alias', Location, Alias}) -> + Meta = meta_from_location(Location), + MetaWithExtra = + case ?token_metadata() of + true -> [{last, meta_from_location(Location)} | Meta]; + false -> Meta + end, + {'__aliases__', MetaWithExtra, [Alias]}. + +build_dot_alias(_Dot, {'__aliases__', Meta, Left}, {'alias', SegmentLocation, Right}) -> + MetaWithExtra = + case ?token_metadata() of + true -> lists:keystore(last, 1, Meta, {last, meta_from_location(SegmentLocation)}); + false -> Meta + end, + {'__aliases__', MetaWithExtra, Left ++ [Right]}; +build_dot_alias(_Dot, Atom, Right) when is_atom(Atom) -> + error_bad_atom(Right); +build_dot_alias(Dot, Expr, {'alias', SegmentLocation, Right}) -> + Meta = meta_from_token(Dot), + MetaWithExtra = + case ?token_metadata() of + true -> [{last, meta_from_location(SegmentLocation)} | Meta]; + false -> Meta + end, + {'__aliases__', MetaWithExtra, [Expr, Right]}. + +build_dot_container(Dot, Left, Right, Extra) -> + Meta = meta_from_token(Dot), + {{'.', Meta, [Left, '{}']}, Extra ++ Meta, Right}. + +build_dot(Dot, Left, {_, Location, _} = Right) -> + Meta = meta_from_token(Dot), + IdentifierLocation = meta_from_location(Location), + {'.', Meta, IdentifierLocation, [Left, extract_identifier(Right)]}. + +extract_identifier({Kind, _, Identifier}) when + Kind == identifier; Kind == bracket_identifier; Kind == paren_identifier; + Kind == do_identifier; Kind == op_identifier -> + Identifier. + +%% Identifiers + +build_nested_parens(Dot, Args1, {Args2Meta, Args2}, {BlockMeta, Block}) -> + Identifier = build_parens(Dot, Args1, {[], []}), + Meta = BlockMeta ++ Args2Meta ++ ?meta(Identifier), + {Identifier, Meta, append_non_empty(Args2, Block)}. + +build_parens(Expr, {ArgsMeta, Args}, {BlockMeta, Block}) -> + {BuiltExpr, BuiltMeta, BuiltArgs} = build_call(Expr, append_non_empty(Args, Block)), + {BuiltExpr, BlockMeta ++ ArgsMeta ++ BuiltMeta, BuiltArgs}. + +build_no_parens_do_block(Expr, Args, {BlockMeta, Block}) -> + {BuiltExpr, BuiltMeta, BuiltArgs} = build_call(Expr, Args ++ Block), + {BuiltExpr, BlockMeta ++ BuiltMeta, BuiltArgs}. + +build_no_parens(Expr, Args) -> + build_call(Expr, Args). + +build_identifier({'.', Meta, IdentifierLocation, DotArgs}) -> + {{'.', Meta, DotArgs}, [{no_parens, true} | IdentifierLocation], []}; + +build_identifier({'.', Meta, _} = Dot) -> + {Dot, [{no_parens, true} | Meta], []}; + +build_identifier({_, Location, Identifier}) -> + {Identifier, meta_from_location(Location), nil}. + +build_call({'.', Meta, IdentifierLocation, DotArgs}, Args) -> + {{'.', Meta, DotArgs}, IdentifierLocation, Args}; + +build_call({'.', Meta, _} = Dot, Args) -> + {Dot, Meta, Args}; + +build_call({op_identifier, Location, Identifier}, [Arg]) -> + {Identifier, [{ambiguous_op, nil} | meta_from_location(Location)], [Arg]}; + +build_call({_, Location, Identifier}, Args) -> + {Identifier, meta_from_location(Location), Args}. + +%% Fn + +build_fn(Fn, Stab, End) -> + case check_stab(Stab, none) of + stab -> + Meta = newlines_op(?location(Fn)) ++ meta_from_token_with_closing(Fn, End), + {fn, Meta, collect_stab(Stab, [], [])}; + block -> + return_error(?location(Fn), "expected anonymous functions to be defined with -> inside: ", "'fn'") + end. + +%% Access + +build_access_arg(Left, Args, Right) -> + {Args, newlines_pair(Left, Right) ++ meta_from_token(Left)}. + +build_access(Expr, {List, Meta}) -> + {{'.', Meta, ['Elixir.Access', get]}, Meta, [Expr, List]}. + +%% Interpolation aware + +build_sigil({sigil, Location, Atom, Parts, Modifiers, Indentation, Delimiter}) -> + Meta = meta_from_location(Location), + MetaWithDelimiter = [{delimiter, Delimiter} | Meta], + MetaWithIndentation = meta_with_indentation(Meta, Indentation), + {Atom, + MetaWithDelimiter, + [{'<<>>', MetaWithIndentation, string_parts(Parts)}, Modifiers]}. + +meta_with_indentation(Meta, nil) -> + Meta; +meta_with_indentation(Meta, Indentation) -> + [{indentation, Indentation} | Meta]. + +meta_with_from_brackets({List, Meta}) -> + {List, [{from_brackets, true} | Meta]}. + +build_bin_heredoc({bin_heredoc, Location, Indentation, Args}) -> + ExtraMeta = + case ?token_metadata() of + true -> [{delimiter, <<$", $", $">>}, {indentation, Indentation}]; + false -> [] + end, + build_bin_string({bin_string, Location, Args}, ExtraMeta). + +build_list_heredoc({list_heredoc, Location, Indentation, Args}) -> + ExtraMeta = + case ?token_metadata() of + true -> [{delimiter, <<$', $', $'>>}, {indentation, Indentation}]; + false -> [] + end, + build_list_string({list_string, Location, Args}, ExtraMeta). + +build_bin_string({bin_string, _Location, [H]} = Token, ExtraMeta) when is_binary(H) -> + handle_literal(H, Token, ExtraMeta); +build_bin_string({bin_string, Location, Args}, ExtraMeta) -> + Meta = + case ?token_metadata() of + true -> ExtraMeta ++ meta_from_location(Location); + false -> meta_from_location(Location) + end, + {'<<>>', Meta, string_parts(Args)}. + +build_list_string({list_string, _Location, [H]} = Token, ExtraMeta) when is_binary(H) -> + handle_literal(elixir_utils:characters_to_list(H), Token, ExtraMeta); +build_list_string({list_string, Location, Args}, ExtraMeta) -> + Meta = meta_from_location(Location), + MetaWithExtra = + case ?token_metadata() of + true -> ExtraMeta ++ Meta; + false -> Meta + end, + {{'.', Meta, ['Elixir.List', to_charlist]}, MetaWithExtra, [charlist_parts(Args)]}. + +build_quoted_atom({_, _Location, [H]} = Token, Safe, ExtraMeta) when is_binary(H) -> + Op = binary_to_atom_op(Safe), + handle_literal(erlang:Op(H, utf8), Token, ExtraMeta); +build_quoted_atom({_, Location, Args}, Safe, ExtraMeta) -> + Meta = meta_from_location(Location), + MetaWithExtra = + case ?token_metadata() of + true -> ExtraMeta ++ Meta; + false -> Meta + end, + {{'.', Meta, [erlang, binary_to_atom_op(Safe)]}, MetaWithExtra, [{'<<>>', Meta, string_parts(Args)}, utf8]}. + +binary_to_atom_op(true) -> binary_to_existing_atom; +binary_to_atom_op(false) -> binary_to_atom. + +charlist_parts(Parts) -> + [charlist_part(Part) || Part <- Parts]. +charlist_part(Binary) when is_binary(Binary) -> + Binary; +charlist_part({Begin, End, Tokens}) -> + Form = string_tokens_parse(Tokens), + Meta = meta_from_location(Begin), + MetaWithExtra = + case ?token_metadata() of + true -> [{closing, meta_from_location(End)} | Meta]; + false -> Meta + end, + {{'.', Meta, ['Elixir.Kernel', to_string]}, [{from_interpolation, true} | MetaWithExtra], [Form]}. + +string_parts(Parts) -> + [string_part(Part) || Part <- Parts]. +string_part(Binary) when is_binary(Binary) -> + Binary; +string_part({Begin, End, Tokens}) -> + Form = string_tokens_parse(Tokens), + Meta = meta_from_location(Begin), + MetaWithExtra = + case ?token_metadata() of + true -> [{closing, meta_from_location(End)} | Meta]; + false -> Meta + end, + {'::', Meta, [{{'.', Meta, ['Elixir.Kernel', to_string]}, [{from_interpolation, true} | MetaWithExtra], [Form]}, {binary, Meta, nil}]}. + +string_tokens_parse(Tokens) -> + case parse(Tokens) of + {ok, Forms} -> Forms; + {error, _} = Error -> throw(Error) + end. + +delimiter(Delimiter) -> + case ?token_metadata() of + true -> [{delimiter, Delimiter}]; + false -> [] + end. + +%% Keywords + +check_stab([{'->', _, [_, _]}], _) -> stab; +check_stab([], none) -> block; +check_stab([_], none) -> block; +check_stab([_], Meta) -> error_invalid_stab(Meta); +check_stab([{'->', Meta, [_, _]} | T], _) -> check_stab(T, Meta); +check_stab([_ | T], MaybeMeta) -> check_stab(T, MaybeMeta). + +build_stab(Stab) -> + case check_stab(Stab, none) of + block -> build_block(reverse(Stab)); + stab -> collect_stab(Stab, [], []) + end. + +build_paren_stab(_Before, [{Op, _, [_]}]=Exprs, _After) when ?rearrange_uop(Op) -> + {'__block__', [], Exprs}; +build_paren_stab(Before, Stab, After) -> + case check_stab(Stab, none) of + block -> build_block(reverse(Stab), meta_from_token_with_closing(Before, After)); + stab -> handle_literal(collect_stab(Stab, [], []), Before, newlines_pair(Before, After)) + end. + +collect_stab([{'->', Meta, [Left, Right]} | T], Exprs, Stabs) -> + Stab = {'->', Meta, [Left, build_block([Right | Exprs])]}, + collect_stab(T, [], [Stab | Stabs]); + +collect_stab([H | T], Exprs, Stabs) -> + collect_stab(T, [H | Exprs], Stabs); + +collect_stab([], [], Stabs) -> + Stabs. + +%% Every time the parser sees a (unquote_splicing()) +%% it assumes that a block is being spliced, wrapping +%% the splicing in a __block__. But in the stab clause, +%% we can have (unquote_splicing(1, 2, 3)) -> :ok, in such +%% case, we don't actually want the block, since it is +%% an arg style call. unwrap_splice unwraps the splice +%% from such blocks. +unwrap_splice([{'__block__', _, [{unquote_splicing, _, _}] = Splice}]) -> + Splice; +unwrap_splice(Other) -> + Other. + +unwrap_when(Args) -> + case elixir_utils:split_last(Args) of + {Start, {'when', Meta, [_, _] = End}} -> + [{'when', Meta, Start ++ End}]; + {_, _} -> + Args + end. + +%% Warnings and errors + +return_error({Line, Column, _}, ErrorMessage, ErrorToken) -> + return_error([{line, Line}, {column, Column}], [ErrorMessage, ErrorToken]). + +%% We should prefer to use return_error as it includes +%% Line and Column but that's not always possible. +return_error_with_meta(Meta, ErrorMessage, ErrorToken) -> + return_error(Meta, [ErrorMessage, ErrorToken]). + +error_invalid_stab(MetaStab) -> + return_error_with_meta(MetaStab, + "unexpected operator ->. If you want to define multiple clauses, the first expression must use ->. " + "Syntax error before: ", "'->'"). + +error_bad_atom(Token) -> + return_error(?location(Token), "atom cannot be followed by an alias. " + "If the '.' was meant to be part of the atom's name, " + "the atom name must be quoted. Syntax error before: ", "'.'"). + +bad_keyword(Token, Context) -> + return_error(?location(Token), + "unexpected keyword list inside " ++ atom_to_list(Context) ++ ". " + "Did you mean to write a map (using %{...}) or a list (using [...]) instead? " + "Syntax error after: ", "'{'"). + +maybe_bad_keyword_call_follow_up(_Token, KW, {'__cursor__', _, []} = Expr) -> + reverse([Expr | KW]); +maybe_bad_keyword_call_follow_up(Token, _KW, _Expr) -> + return_error(?location(Token), + "unexpected expression after keyword list. Keyword lists must always come as the last argument. Therefore, this is not allowed:\n\n" + " function_call(1, some: :option, 2)\n\n" + "Instead, wrap the keyword in brackets:\n\n" + " function_call(1, [some: :option], 2)\n\n" + "Syntax error after: ", "','"). + +maybe_bad_keyword_data_follow_up(_Token, KW, {'__cursor__', _, []} = Expr) -> + reverse([Expr | KW]); +maybe_bad_keyword_data_follow_up(Token, _KW, _Expr) -> + return_error(?location(Token), + "unexpected expression after keyword list. Keyword lists must always come last in lists and maps. Therefore, this is not allowed:\n\n" + " [some: :value, :another]\n" + " %{some: :value, another => value}\n\n" + "Instead, reorder it to be the last entry:\n\n" + " [:another, some: :value]\n" + " %{another => value, some: :value}\n\n" + "Syntax error after: ", "','"). + +error_no_parens_strict(Token) -> + return_error(?location(Token), "unexpected parentheses. If you are making a " + "function call, do not insert spaces between the function name and the " + "opening parentheses. Syntax error before: ", "'('"). + +error_no_parens_many_strict(Node) -> + return_error_with_meta(?meta(Node), + "unexpected comma. Parentheses are required to solve ambiguity in nested calls.\n\n" + "This error happens when you have nested function calls without parentheses. " + "For example:\n\n" + " parent_call a, nested_call b, c, d\n\n" + "In the example above, we don't know if the parameters \"c\" and \"d\" apply " + "to the function \"parent_call\" or \"nested_call\". You can solve this by " + "explicitly adding parentheses:\n\n" + " parent_call a, nested_call(b, c, d)\n\n" + "Or by adding commas (in case a nested call is not intended):\n\n" + " parent_call a, nested_call, b, c, d\n\n" + "Elixir cannot compile otherwise. Syntax error before: ", "','"). + +error_no_parens_container_strict(Node) -> + return_error_with_meta(?meta(Node), + "unexpected comma. Parentheses are required to solve ambiguity inside containers.\n\n" + "This error may happen when you forget a comma in a list or other container:\n\n" + " [a, b c, d]\n\n" + "Or when you have ambiguous calls:\n\n" + " [function a, b, c]\n\n" + "In the example above, we don't know if the values \"b\" and \"c\" " + "belongs to the list or the function \"function\". You can solve this by explicitly " + "adding parentheses:\n\n" + " [one, function(a, b, c)]\n\n" + "Elixir cannot compile otherwise. Syntax error before: ", "','"). + +error_too_many_access_syntax(Comma) -> + return_error(?location(Comma), "too many arguments when accessing a value. " + "The value[key] notation in Elixir expects either a single argument or a keyword list. " + "The following examples are allowed:\n\n" + " value[one]\n" + " value[one: 1, two: 2]\n" + " value[[one, two, three]]\n\n" + "These are invalid:\n\n" + " value[1, 2, 3]\n" + " value[one, two, three]\n\n" + "Syntax error after: ", "','"). + +error_invalid_kw_identifier({_, Location, do}) -> + return_error(Location, elixir_tokenizer:invalid_do_error("unexpected keyword: "), "do:"); +error_invalid_kw_identifier({_, Location, KW}) -> + return_error(Location, "syntax error before: ", "'" ++ atom_to_list(KW) ++ ":'"). + +%% TODO: Make this an error on v2.0 +warn_trailing_comma({',', {Line, Column, _}}) -> + warn({Line, Column}, "trailing commas are not allowed inside function/macro call arguments"). + +%% TODO: Make this an error on v2.0 +warn_pipe({arrow_op, {Line, Column, _}, Op}, {_, [_ | _], [_ | _]}) -> + warn( + {Line, Column}, + io_lib:format( + "parentheses are required when piping into a function call. For example:\n\n" + " foo 1 ~ts bar 2 ~ts baz 3\n\n" + "is ambiguous and should be written as\n\n" + " foo(1) ~ts bar(2) ~ts baz(3)\n\n" + "Ambiguous pipe found at:", + [Op, Op, Op, Op] + ) + ); +warn_pipe(_Token, _) -> + ok. + +%% TODO: Make this an error on v2.0 +warn_no_parens_after_do_op({{_Type, Location, Op}, _}) -> + {Line, _, _} = Location, + + warn( + Line, + "missing parentheses on expression following operator \"" ++ atom_to_list(Op) ++ "\", " + "you must add parentheses to avoid ambiguities" + ). + +%% TODO: Make this an error on v2.0 +warn_nested_no_parens_keyword(Key, Value) when is_atom(Key) -> + {line, Line} = lists:keyfind(line, 1, ?meta(Value)), + warn( + Line, + "missing parentheses for expression following \"" ++ atom_to_list(Key) ++ ":\" keyword. " + "Parentheses are required to solve ambiguity inside keywords.\n\n" + "This error happens when you have function calls without parentheses inside keywords. " + "For example:\n\n" + " function(arg, one: nested_call a, b, c)\n" + " function(arg, one: if expr, do: :this, else: :that)\n\n" + "In the examples above, we don't know if the arguments \"b\" and \"c\" apply " + "to the function \"function\" or \"nested_call\". Or if the keywords \"do\" and " + "\"else\" apply to the function \"function\" or \"if\". You can solve this by " + "explicitly adding parentheses:\n\n" + " function(arg, one: if(expr, do: :this, else: :that))\n" + " function(arg, one: nested_call(a, b, c))\n\n" + "Ambiguity found at:" + ); + +% Key might not be an atom when using literal_encoder, we just skip the warning +warn_nested_no_parens_keyword(_Key, _Value) -> + ok. + +warn_empty_paren({_, {Line, Column, _}}) -> + warn( + {Line, Column}, + "invalid expression (). " + "If you want to invoke or define a function, make sure there are " + "no spaces between the function name and its arguments. If you wanted " + "to pass an empty block or code, pass a value instead, such as a nil or an atom" + ). + +warn_empty_stab_clause({stab_op, {Line, Column, _}, '->'}) -> + warn( + {Line, Column}, + "an expression is always required on the right side of ->. " + "Please provide a value after ->" + ). + +warn(LineColumn, Message) -> + case get(elixir_parser_warning_file) of + nil -> ok; + File -> future_elixir_errors:erl_warn(LineColumn, File, Message) + end. + +-file("/nix/store/xlav8m7x7v9wqhdqmzf4cnw3px12gsag-erlang-27.0/lib/erlang/lib/parsetools-2.6/include/yeccpre.hrl", 0). +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 1996-2024. All Rights Reserved. +%% +%% Licensed under the Apache License, Version 2.0 (the "License"); +%% you may not use this file except in compliance with the License. +%% You may obtain a copy of the License at +%% +%% http://www.apache.org/licenses/LICENSE-2.0 +%% +%% Unless required by applicable law or agreed to in writing, software +%% distributed under the License is distributed on an "AS IS" BASIS, +%% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +%% See the License for the specific language governing permissions and +%% limitations under the License. +%% +%% %CopyrightEnd% +%% + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +% The parser generator will insert appropriate declarations before this line.% + +-type yecc_ret() :: {'error', _} | {'ok', _}. + +-ifdef (YECC_PARSE_DOC). +-doc ?YECC_PARSE_DOC. +-endif. +-spec parse(Tokens :: list()) -> yecc_ret(). +parse(Tokens) -> + yeccpars0(Tokens, {no_func, no_location}, 0, [], []). + +-ifdef (YECC_PARSE_AND_SCAN_DOC). +-doc ?YECC_PARSE_AND_SCAN_DOC. +-endif. +-spec parse_and_scan({function() | {atom(), atom()}, [_]} + | {atom(), atom(), [_]}) -> yecc_ret(). +parse_and_scan({F, A}) -> + yeccpars0([], {{F, A}, no_location}, 0, [], []); +parse_and_scan({M, F, A}) -> + Arity = length(A), + yeccpars0([], {{fun M:F/Arity, A}, no_location}, 0, [], []). + +-ifdef (YECC_FORMAT_ERROR_DOC). +-doc ?YECC_FORMAT_ERROR_DOC. +-endif. +-spec format_error(any()) -> [char() | list()]. +format_error(Message) -> + case io_lib:deep_char_list(Message) of + true -> + Message; + _ -> + io_lib:write(Message) + end. + +%% To be used in grammar files to throw an error message to the parser +%% toplevel. Doesn't have to be exported! +-compile({nowarn_unused_function, return_error/2}). +-spec return_error(erl_anno:location(), any()) -> no_return(). +return_error(Location, Message) -> + throw({error, {Location, ?MODULE, Message}}). + +-define(CODE_VERSION, "1.4"). + +yeccpars0(Tokens, Tzr, State, States, Vstack) -> + try yeccpars1(Tokens, Tzr, State, States, Vstack) + catch + error: Error: Stacktrace -> + try yecc_error_type(Error, Stacktrace) of + Desc -> + erlang:raise(error, {yecc_bug, ?CODE_VERSION, Desc}, + Stacktrace) + catch _:_ -> erlang:raise(error, Error, Stacktrace) + end; + %% Probably thrown from return_error/2: + throw: {error, {_Location, ?MODULE, _M}} = Error -> + Error + end. + +yecc_error_type(function_clause, [{?MODULE,F,ArityOrArgs,_} | _]) -> + case atom_to_list(F) of + "yeccgoto_" ++ SymbolL -> + {ok,[{atom,_,Symbol}],_} = erl_scan:string(SymbolL), + State = case ArityOrArgs of + [S,_,_,_,_,_,_] -> S; + _ -> state_is_unknown + end, + {Symbol, State, missing_in_goto_table} + end. + +yeccpars1([Token | Tokens], Tzr, State, States, Vstack) -> + yeccpars2(State, element(1, Token), States, Vstack, Token, Tokens, Tzr); +yeccpars1([], {{F, A},_Location}, State, States, Vstack) -> + case apply(F, A) of + {ok, Tokens, EndLocation} -> + yeccpars1(Tokens, {{F, A}, EndLocation}, State, States, Vstack); + {eof, EndLocation} -> + yeccpars1([], {no_func, EndLocation}, State, States, Vstack); + {error, Descriptor, _EndLocation} -> + {error, Descriptor} + end; +yeccpars1([], {no_func, no_location}, State, States, Vstack) -> + Line = 999999, + yeccpars2(State, '$end', States, Vstack, yecc_end(Line), [], + {no_func, Line}); +yeccpars1([], {no_func, EndLocation}, State, States, Vstack) -> + yeccpars2(State, '$end', States, Vstack, yecc_end(EndLocation), [], + {no_func, EndLocation}). + +%% yeccpars1/7 is called from generated code. +%% +%% When using the {includefile, Includefile} option, make sure that +%% yeccpars1/7 can be found by parsing the file without following +%% include directives. yecc will otherwise assume that an old +%% yeccpre.hrl is included (one which defines yeccpars1/5). +yeccpars1(State1, State, States, Vstack, Token0, [Token | Tokens], Tzr) -> + yeccpars2(State, element(1, Token), [State1 | States], + [Token0 | Vstack], Token, Tokens, Tzr); +yeccpars1(State1, State, States, Vstack, Token0, [], {{_F,_A}, _Location}=Tzr) -> + yeccpars1([], Tzr, State, [State1 | States], [Token0 | Vstack]); +yeccpars1(State1, State, States, Vstack, Token0, [], {no_func, no_location}) -> + Location = yecctoken_end_location(Token0), + yeccpars2(State, '$end', [State1 | States], [Token0 | Vstack], + yecc_end(Location), [], {no_func, Location}); +yeccpars1(State1, State, States, Vstack, Token0, [], {no_func, Location}) -> + yeccpars2(State, '$end', [State1 | States], [Token0 | Vstack], + yecc_end(Location), [], {no_func, Location}). + +%% For internal use only. +yecc_end(Location) -> + {'$end', Location}. + +yecctoken_end_location(Token) -> + try erl_anno:end_location(element(2, Token)) of + undefined -> yecctoken_location(Token); + Loc -> Loc + catch _:_ -> yecctoken_location(Token) + end. + +-compile({nowarn_unused_function, yeccerror/1}). +yeccerror(Token) -> + Text = yecctoken_to_string(Token), + Location = yecctoken_location(Token), + {error, {Location, ?MODULE, ["syntax error before: ", Text]}}. + +-compile({nowarn_unused_function, yecctoken_to_string/1}). +yecctoken_to_string(Token) -> + try erl_scan:text(Token) of + undefined -> yecctoken2string(Token); + Txt -> Txt + catch _:_ -> yecctoken2string(Token) + end. + +yecctoken_location(Token) -> + try erl_scan:location(Token) + catch _:_ -> element(2, Token) + end. + +-compile({nowarn_unused_function, yecctoken2string/1}). +yecctoken2string(Token) -> + try + yecctoken2string1(Token) + catch + _:_ -> + io_lib:format("~tp", [Token]) + end. + +-compile({nowarn_unused_function, yecctoken2string1/1}). +yecctoken2string1({atom, _, A}) -> io_lib:write_atom(A); +yecctoken2string1({integer,_,N}) -> io_lib:write(N); +yecctoken2string1({float,_,F}) -> io_lib:write(F); +yecctoken2string1({char,_,C}) -> io_lib:write_char(C); +yecctoken2string1({var,_,V}) -> io_lib:format("~s", [V]); +yecctoken2string1({string,_,S}) -> io_lib:write_string(S); +yecctoken2string1({reserved_symbol, _, A}) -> io_lib:write(A); +yecctoken2string1({_Cat, _, Val}) -> io_lib:format("~tp", [Val]); +yecctoken2string1({dot, _}) -> "'.'"; +yecctoken2string1({'$end', _}) -> []; +yecctoken2string1({Other, _}) when is_atom(Other) -> + io_lib:write_atom(Other); +yecctoken2string1(Other) -> + io_lib:format("~tp", [Other]). + +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + +-file("src/future_elixir_parser.erl", 829). + +-dialyzer({nowarn_function, yeccpars2/7}). +-compile({nowarn_unused_function, yeccpars2/7}). +yeccpars2(0=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_0(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(1=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_1(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(2=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(3=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_3(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(4=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_4(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(5=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_5(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(6=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_6(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(7=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_7(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(8=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_8(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(9=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_9(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(10=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_10(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(11=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_11(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(12=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_12(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(13=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_13(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(14=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_14(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(15=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_15(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(16=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_16(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(17=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_17(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(18=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_18(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(19=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_19(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(20=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_20(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(21=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_21(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(22=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_22(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(23=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_23(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(24=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_24(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(25=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_25(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(26=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(27=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_27(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(28=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_28(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(29=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_29(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(30=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_30(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(31=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_31(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(32=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(33=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_33(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(34=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_34(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(35=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_35(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(36=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_36(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(37=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(38=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_38(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(39=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(40=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_40(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(41=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_41(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(42=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_42(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(43=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_43(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(44=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_44(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(45=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_45(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(46=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_46(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(47=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_47(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(48=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_48(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(49=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_49(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(50=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_50(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(51=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_51(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(52=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_52(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(53=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_53(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(54=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_54(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(55=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_55(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(56=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_56(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(57=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_57(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(58=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_58(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(59=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_59(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(60=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_60(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(61=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_61(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(62=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_62(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(63=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_63(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(64=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_64(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(65=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_65(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(66=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_66(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(67=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_67(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(68=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_68(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(69=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_69(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(70=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_70(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(71=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_71(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(72=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_72(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(73=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_73(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(74=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_74(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(75=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_75(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(76=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_76(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(77=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_77(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(78=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_78(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(79=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_79(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(80=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_80(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(81=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_81(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(82=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_82(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(83=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_83(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(84=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_84(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(85=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(86=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_86(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(87=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_87(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(88=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(89=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(90=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(91=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(92=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(93=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(94=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(95=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_95(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(96=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(97=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_97(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(98=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(99=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(100=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(101=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(102=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_102(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(103=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(104=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(105=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(106=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(107=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_107(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(108=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_108(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(109=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_109(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(110=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_110(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(111=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_111(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(112=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_112(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(113=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_113(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(114=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_114(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(115=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_115(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(116=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_116(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(117=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_117(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(118=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_118(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(119=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_119(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(120=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_120(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(121=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_121(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(122=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_122(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(123=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_123(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(124=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_124(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(125=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_125(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(126=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_126(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(127=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_127(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(128=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_128(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(129=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_129(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(130=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_130(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(131=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_131(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(132=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_132(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(133=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_133(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(134=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_134(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(135=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_135(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(136=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_136(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(137=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_137(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(138=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_138(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(139=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_139(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(140=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_140(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(141=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_141(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(142=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_142(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(143=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_143(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(144=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_144(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(145=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_145(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(146=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_146(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(147=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_147(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(148=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_148(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(149=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_149(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(150=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_150(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(151=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_151(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(152=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_152(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(153=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_153(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(154=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_154(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(155=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_155(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(156=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_156(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(157=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_157(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(158=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_158(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(159=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_159(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(160=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_160(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(161=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_161(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(162=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_162(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(163=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_163(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(164=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_164(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(165=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_165(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(166=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_166(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(167=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_167(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(168=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_168(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(169=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_169(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(170=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_170(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(171=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_171(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(172=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_172(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(173=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_173(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(174=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(175=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_175(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(176=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_176(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(177=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_177(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(178=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_178(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(179=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_179(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(180=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_180(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(181=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(182=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_182(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(183=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_183(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(184=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_184(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(185=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_185(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(186=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_186(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(187=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_187(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(188=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_188(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(189=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_189(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(190=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_190(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(191=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_191(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(192=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(193=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_193(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(194=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(195=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_195(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(196=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_196(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(197=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_197(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(198=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_29(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(199=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(200=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(201=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_201(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(202=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_202(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(203=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(204=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(205=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(206=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(207=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(208=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(209=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(210=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(211=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(212=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(213=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(214=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(215=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(216=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(217=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(218=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(219=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(220=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(221=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_221(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(222=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_222(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(223=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_223(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(224=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_224(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(225=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_225(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(226=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_226(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(227=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_227(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(228=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_228(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(229=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_229(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(230=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_230(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(231=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_231(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(232=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_232(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(233=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_233(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(234=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_234(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(235=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_235(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(236=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_236(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(237=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_237(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(238=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_238(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(239=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_239(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(240=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_30(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(241=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_241(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(242=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_86(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(243=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_243(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(244=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_244(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(245=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_245(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(246=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_246(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(247=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_247(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(248=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_248(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(249=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_249(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(250=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_250(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(251=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_251(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(252=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_245(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(253=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_253(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(254=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_254(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(255=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_255(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(256=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_256(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(257=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_257(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(258=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_258(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(259=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_259(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(260=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_260(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(261=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_261(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(262=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_262(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(263=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_263(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(264=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_264(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(265=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_265(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(266=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_266(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(267=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_267(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(268=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_268(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(269=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_269(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(270=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_270(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(271=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(272=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_272(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(273=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_273(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(274=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_274(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(275=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_264(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(276=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_276(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(277=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_277(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(278=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_278(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(279=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_279(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(280=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_280(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(281=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_281(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(282=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_282(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(283=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(284=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_284(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(285=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_285(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(286=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_286(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(287=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(288=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_288(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(289=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_289(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(290=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(291=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_291(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(292=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_292(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(293=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(294=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_294(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(295=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(296=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(297=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_297(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(298=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_298(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(299=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_299(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(300=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(301=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(302=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(303=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(304=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(305=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(306=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(307=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(308=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(309=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(310=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(311=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(312=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(313=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(314=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(315=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(316=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(317=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(318=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_318(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(319=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_319(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(320=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_320(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(321=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_321(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(322=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_322(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(323=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_323(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(324=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_324(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(325=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_325(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(326=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_326(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(327=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_327(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(328=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_328(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(329=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_329(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(330=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_330(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(331=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_331(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(332=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_332(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(333=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_333(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(334=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_334(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(335=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_335(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(336=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_336(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(337=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_337(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(338=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_338(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(339=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_339(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(340=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_340(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(341=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_341(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(342=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_342(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(343=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_343(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(344=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_344(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(345=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_345(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(346=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_346(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(347=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_347(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(348=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_348(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(349=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_349(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(350=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_350(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(351=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_351(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(352=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_352(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(353=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_353(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(354=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_354(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(355=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_6(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(356=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_356(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(357=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_357(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(358=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_358(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(359=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_359(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(360=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_360(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(361=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_361(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(362=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(363=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_363(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(364=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_364(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(365=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_365(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(366=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_366(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(367=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(368=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_368(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(369=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_369(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(370=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_370(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(371=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_371(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(372=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_372(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(373=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_373(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(374=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_374(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(375=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_375(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(376=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_6(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(377=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_377(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(378=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_378(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(379=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_379(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(380=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_380(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(381=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_381(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(382=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_382(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(383=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_383(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(384=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_384(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(385=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(386=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_386(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(387=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_387(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(388=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_388(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(389=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_389(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(390=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_390(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(391=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_391(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(392=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_392(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(393=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_393(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(394=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_394(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(395=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_395(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(396=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_396(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(397=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_397(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(398=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(399=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(400=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_400(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(401=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_401(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(402=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_402(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(403=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_403(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(404=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_404(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(405=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_405(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(406=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_406(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(407=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_407(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(408=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_408(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(409=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_409(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(410=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(411=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_385(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(412=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_412(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(413=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_413(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(414=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_414(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(415=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_415(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(416=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_416(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(417=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_417(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(418=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_418(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(419=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_419(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(420=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_420(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(421=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_421(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(422=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_422(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(423=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_423(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(424=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_424(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(425=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_425(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(426=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_426(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(427=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_427(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(428=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_428(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(429=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_429(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(430=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_430(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(431=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_431(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(432=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_432(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(433=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_433(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(434=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_434(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(435=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_435(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(436=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_436(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(437=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_437(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(438=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_438(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(439=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_439(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(440=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_440(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(441=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_441(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(442=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_442(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(443=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_443(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(444=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_444(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(445=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_445(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(446=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_446(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(447=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_447(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(448=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_448(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(449=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_449(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(450=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_450(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(451=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_451(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(452=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_452(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(453=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_453(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(454=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_454(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(455=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_455(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(456=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_456(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(457=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_39(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(458=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_458(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(459=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_459(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(460=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_460(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(461=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_39(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(462=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_462(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(463=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_463(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(464=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_464(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(465=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_465(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(466=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_466(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(467=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(468=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_468(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(469=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_469(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(470=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_470(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(471=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_471(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(472=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_472(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(473=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_473(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(474=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(475=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(476=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_476(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(477=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(478=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_470(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(479=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(480=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_480(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(481=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_481(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(482=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_482(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(483=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(484=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_484(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(485=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_485(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(486=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_470(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(487=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_470(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(488=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_488(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(489=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_489(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(490=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_490(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(491=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_491(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(492=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_492(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(493=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_493(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(494=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_494(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(495=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_495(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(496=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_496(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(497=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_497(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(498=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_469(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(499=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_471(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(500=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(501=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_501(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(502=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_502(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(503=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(504=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(505=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(506=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(507=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(508=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(509=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(510=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(511=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(512=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(513=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(514=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(515=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(516=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(517=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(518=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(519=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(520=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(521=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(522=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_522(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(523=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_523(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(524=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(525=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_525(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(526=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(527=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_527(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(528=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_528(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(529=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_529(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(530=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_530(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(531=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_531(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(532=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_532(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(533=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_533(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(534=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_534(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(535=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_535(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(536=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_536(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(537=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_537(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(538=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_538(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(539=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_539(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(540=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_540(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(541=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_541(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(542=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_542(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(543=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_543(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(544=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_544(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(545=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_545(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(546=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_546(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(547=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(548=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_548(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(549=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_549(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(550=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_550(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(551=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_551(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(552=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_552(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(553=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_553(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(554=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_554(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(555=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_555(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(556=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_556(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(557=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_557(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(558=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_558(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(559=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_559(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(560=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_560(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(561=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_561(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(562=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_562(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(563=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_563(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(564=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_564(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(565=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_565(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(566=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_566(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(567=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_567(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(568=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_568(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(569=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_569(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(570=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_570(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(571=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_571(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(572=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_572(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(573=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_573(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(574=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_574(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(575=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_575(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(576=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_576(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(577=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_558(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(578=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_578(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(579=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_579(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(580=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_580(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(581=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_581(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(582=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_582(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(583=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_583(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(584=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_584(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(585=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_585(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(586=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_586(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(587=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_587(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(588=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_588(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(589=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_589(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(590=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_590(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(591=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_591(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(592=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_592(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(593=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_593(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(594=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_594(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(595=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_595(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(596=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_596(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(597=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_597(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(598=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_598(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(599=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_599(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(600=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_600(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(601=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_601(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(602=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_602(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(603=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_603(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(604=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_604(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(605=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_605(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(606=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_606(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(607=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_607(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(608=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_608(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(609=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_609(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(610=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_610(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(611=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_611(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(612=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_612(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(613=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_613(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(614=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_614(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(615=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_245(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(616=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_616(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(617=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_617(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(618=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_618(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(619=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_619(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(620=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_620(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(621=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_621(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(622=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_622(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(623=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(624=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_624(S, Cat, Ss, Stack, T, Ts, Tzr); +%% yeccpars2(625=S, Cat, Ss, Stack, T, Ts, Tzr) -> +%% yeccpars2_625(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(626=S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_626(S, Cat, Ss, Stack, T, Ts, Tzr); +yeccpars2(Other, _, _, _, _, _, _) -> + erlang:error({yecc_bug,"1.4",{missing_state_in_action_table, Other}}). + +-dialyzer({nowarn_function, yeccpars2_0/7}). +-compile({nowarn_unused_function, yeccpars2_0/7}). +yeccpars2_0(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_0(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_0_(Stack), + yeccpars2_19(19, Cat, [0 | Ss], NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_1/7}). +-compile({nowarn_unused_function, yeccpars2_1/7}). +yeccpars2_1(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_1(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_1_(Stack), + yeccgoto_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_2(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_2(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_2(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_2(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_2(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_2/7}). +-compile({nowarn_unused_function, yeccpars2_2/7}). +yeccpars2_cont_2(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_2(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_3/7}). +-compile({nowarn_unused_function, yeccpars2_3/7}). +yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_3_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_4/7}). +-compile({nowarn_unused_function, yeccpars2_4/7}). +yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_4_(Stack), + yeccgoto_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_5/7}). +-compile({nowarn_unused_function, yeccpars2_5/7}). +yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_5_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_6(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 386, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 387, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_6(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +yeccpars2_7(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 624, Ss, Stack, T, Ts, Tzr); +yeccpars2_7(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +yeccpars2_8(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, ']', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 618, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_8(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +yeccpars2_9(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, '>>', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 609, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_9(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_10/7}). +-compile({nowarn_unused_function, yeccpars2_10/7}). +yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_10_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_11/7}). +-compile({nowarn_unused_function, yeccpars2_11/7}). +yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_11_(Stack), + yeccgoto_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_12/7}). +-compile({nowarn_unused_function, yeccpars2_12/7}). +yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_12_(Stack), + yeccgoto_no_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_13/7}). +-compile({nowarn_unused_function, yeccpars2_13/7}). +yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_13_(Stack), + yeccgoto_no_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_14/7}). +-compile({nowarn_unused_function, yeccpars2_14/7}). +yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_14_(Stack), + yeccgoto_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_15/7}). +-compile({nowarn_unused_function, yeccpars2_15/7}). +yeccpars2_15(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_15(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_15_(Stack), + yeccgoto_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_16/7}). +-compile({nowarn_unused_function, yeccpars2_16/7}). +yeccpars2_16(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_16(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_17/7}). +-compile({nowarn_unused_function, yeccpars2_17/7}). +yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_17_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_18/7}). +-compile({nowarn_unused_function, yeccpars2_18/7}). +yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_18_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_19/7}). +-compile({nowarn_unused_function, yeccpars2_19/7}). +yeccpars2_19(_S, '$end', _Ss, Stack, _T, _Ts, _Tzr) -> + {ok, hd(Stack)}; +yeccpars2_19(_, _, _, _, T, _, _) -> + yeccerror(T). + +yeccpars2_20(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_20(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_21/7}). +-compile({nowarn_unused_function, yeccpars2_21/7}). +yeccpars2_21(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_21(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_21(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_21_(Stack), + yeccgoto_grammar(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_22/7}). +-compile({nowarn_unused_function, yeccpars2_22/7}). +yeccpars2_22(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_22_(Stack), + yeccgoto_expr_list(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_23/7}). +-compile({nowarn_unused_function, yeccpars2_23/7}). +yeccpars2_23(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_23(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_23_(Stack), + yeccgoto_grammar(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_24/7}). +-compile({nowarn_unused_function, yeccpars2_24/7}). +yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_24_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_25/7}). +-compile({nowarn_unused_function, yeccpars2_25/7}). +yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_25_(Stack), + yeccgoto_dot_call_identifier(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_26(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_26(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_27/7}). +-compile({nowarn_unused_function, yeccpars2_27/7}). +yeccpars2_27(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_27(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_27_(Stack), + yeccgoto_no_parens_zero_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_28/7}). +-compile({nowarn_unused_function, yeccpars2_28/7}). +yeccpars2_28(S, 'do', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 561, Ss, Stack, T, Ts, Tzr); +yeccpars2_28(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_28_(Stack), + yeccgoto_no_parens_zero_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_29/7}). +-compile({nowarn_unused_function, yeccpars2_29/7}). +yeccpars2_29(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_29(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_30/7}). +-compile({nowarn_unused_function, yeccpars2_30/7}). +yeccpars2_30(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_30(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_31/7}). +-compile({nowarn_unused_function, yeccpars2_31/7}). +yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_31_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_32: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_33/7}). +-compile({nowarn_unused_function, yeccpars2_33/7}). +yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_33_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_34/7}). +-compile({nowarn_unused_function, yeccpars2_34/7}). +yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_34_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_35/7}). +-compile({nowarn_unused_function, yeccpars2_35/7}). +yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_35_(Stack), + yeccgoto_unmatched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_36/7}). +-compile({nowarn_unused_function, yeccpars2_36/7}). +yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_36_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_37: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_38/7}). +-compile({nowarn_unused_function, yeccpars2_38/7}). +yeccpars2_38(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_38(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 244, Ss, Stack, T, Ts, Tzr); +yeccpars2_38(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_38_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_39(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_39(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_39(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 462, Ss, Stack, T, Ts, Tzr); +yeccpars2_39(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_39(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_40/7}). +-compile({nowarn_unused_function, yeccpars2_40/7}). +yeccpars2_40(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 456, Ss, Stack, T, Ts, Tzr); +yeccpars2_40(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_40_(Stack), + yeccgoto_map_op(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_41/7}). +-compile({nowarn_unused_function, yeccpars2_41/7}). +yeccpars2_41(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 455, Ss, Stack, T, Ts, Tzr); +yeccpars2_41(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_41_(Stack), + yeccgoto_open_paren(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_42/7}). +-compile({nowarn_unused_function, yeccpars2_42/7}). +yeccpars2_42(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_42_(Stack), + yeccgoto_eoe(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_43/7}). +-compile({nowarn_unused_function, yeccpars2_43/7}). +yeccpars2_43(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 454, Ss, Stack, T, Ts, Tzr); +yeccpars2_43(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_43_(Stack), + yeccgoto_open_bit(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_44/7}). +-compile({nowarn_unused_function, yeccpars2_44/7}). +yeccpars2_44(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 453, Ss, Stack, T, Ts, Tzr); +yeccpars2_44(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_44_(Stack), + yeccgoto_open_bracket(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_45/7}). +-compile({nowarn_unused_function, yeccpars2_45/7}). +yeccpars2_45(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_45_(Stack), + yeccgoto_dot_alias(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_46/7}). +-compile({nowarn_unused_function, yeccpars2_46/7}). +yeccpars2_46(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 452, Ss, Stack, T, Ts, Tzr); +yeccpars2_46(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_46_(Stack), + yeccgoto_at_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_47/7}). +-compile({nowarn_unused_function, yeccpars2_47/7}). +yeccpars2_47(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_47_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_48/7}). +-compile({nowarn_unused_function, yeccpars2_48/7}). +yeccpars2_48(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_48_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_49/7}). +-compile({nowarn_unused_function, yeccpars2_49/7}). +yeccpars2_49(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_49_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_50/7}). +-compile({nowarn_unused_function, yeccpars2_50/7}). +yeccpars2_50(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_50_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_51/7}). +-compile({nowarn_unused_function, yeccpars2_51/7}). +yeccpars2_51(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_51_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_52/7}). +-compile({nowarn_unused_function, yeccpars2_52/7}). +yeccpars2_52(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_52_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_53/7}). +-compile({nowarn_unused_function, yeccpars2_53/7}). +yeccpars2_53(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_53_(Stack), + yeccgoto_dot_bracket_identifier(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_54/7}). +-compile({nowarn_unused_function, yeccpars2_54/7}). +yeccpars2_54(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 451, Ss, Stack, T, Ts, Tzr); +yeccpars2_54(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_55/7}). +-compile({nowarn_unused_function, yeccpars2_55/7}). +yeccpars2_55(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 450, Ss, Stack, T, Ts, Tzr); +yeccpars2_55(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_55_(Stack), + yeccgoto_capture_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_56/7}). +-compile({nowarn_unused_function, yeccpars2_56/7}). +yeccpars2_56(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_56_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_57/7}). +-compile({nowarn_unused_function, yeccpars2_57/7}). +yeccpars2_57(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_57_(Stack), + yeccgoto_dot_do_identifier(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_58/7}). +-compile({nowarn_unused_function, yeccpars2_58/7}). +yeccpars2_58(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 449, Ss, Stack, T, Ts, Tzr); +yeccpars2_58(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_58_(Stack), + yeccgoto_unary_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_59/7}). +-compile({nowarn_unused_function, yeccpars2_59/7}). +yeccpars2_59(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_59(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_59_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_60/7}). +-compile({nowarn_unused_function, yeccpars2_60/7}). +yeccpars2_60(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 81, Ss, Stack, T, Ts, Tzr); +yeccpars2_60(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_60_(Stack), + yeccgoto_eoe(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_61/7}). +-compile({nowarn_unused_function, yeccpars2_61/7}). +yeccpars2_61(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_61_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_62/7}). +-compile({nowarn_unused_function, yeccpars2_62/7}). +yeccpars2_62(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_62_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_63/7}). +-compile({nowarn_unused_function, yeccpars2_63/7}). +yeccpars2_63(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_63(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_63(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_63_(Stack), + yeccgoto_fn_eoe(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_64/7}). +-compile({nowarn_unused_function, yeccpars2_64/7}). +yeccpars2_64(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_64_(Stack), + yeccgoto_dot_identifier(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_65/7}). +-compile({nowarn_unused_function, yeccpars2_65/7}). +yeccpars2_65(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_65_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_66/7}). +-compile({nowarn_unused_function, yeccpars2_66/7}). +yeccpars2_66(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_66_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_67/7}). +-compile({nowarn_unused_function, yeccpars2_67/7}). +yeccpars2_67(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_67_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_68/7}). +-compile({nowarn_unused_function, yeccpars2_68/7}). +yeccpars2_68(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_68_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_69/7}). +-compile({nowarn_unused_function, yeccpars2_69/7}). +yeccpars2_69(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_69_(Stack), + yeccgoto_dot_op_identifier(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_70/7}). +-compile({nowarn_unused_function, yeccpars2_70/7}). +yeccpars2_70(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_70_(Stack), + yeccgoto_dot_paren_identifier(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_71/7}). +-compile({nowarn_unused_function, yeccpars2_71/7}). +yeccpars2_71(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_71_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_72/7}). +-compile({nowarn_unused_function, yeccpars2_72/7}). +yeccpars2_72(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_72_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_73/7}). +-compile({nowarn_unused_function, yeccpars2_73/7}). +yeccpars2_73(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 79, Ss, Stack, T, Ts, Tzr); +yeccpars2_73(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_73_(Stack), + yeccgoto_unary_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_74/7}). +-compile({nowarn_unused_function, yeccpars2_74/7}). +yeccpars2_74(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_74_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_75/7}). +-compile({nowarn_unused_function, yeccpars2_75/7}). +yeccpars2_75(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 78, Ss, Stack, T, Ts, Tzr); +yeccpars2_75(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_75_(Stack), + yeccgoto_unary_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_76/7}). +-compile({nowarn_unused_function, yeccpars2_76/7}). +yeccpars2_76(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 77, Ss, Stack, T, Ts, Tzr); +yeccpars2_76(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_76_(Stack), + yeccgoto_open_curly(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_77/7}). +-compile({nowarn_unused_function, yeccpars2_77/7}). +yeccpars2_77(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_77_(Stack), + yeccgoto_open_curly(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_78/7}). +-compile({nowarn_unused_function, yeccpars2_78/7}). +yeccpars2_78(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_78_(Stack), + yeccgoto_unary_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_79/7}). +-compile({nowarn_unused_function, yeccpars2_79/7}). +yeccpars2_79(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_79_(Stack), + yeccgoto_unary_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_80/7}). +-compile({nowarn_unused_function, yeccpars2_80/7}). +yeccpars2_80(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_80_(Stack), + yeccgoto_fn_eoe(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_81/7}). +-compile({nowarn_unused_function, yeccpars2_81/7}). +yeccpars2_81(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_81_(Stack), + yeccgoto_eoe(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_82/7}). +-compile({nowarn_unused_function, yeccpars2_82/7}). +yeccpars2_82(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_82_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_83/7}). +-compile({nowarn_unused_function, yeccpars2_83/7}). +yeccpars2_83(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_83(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_83_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_84/7}). +-compile({nowarn_unused_function, yeccpars2_84/7}). +yeccpars2_84(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_84_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_85: see yeccpars2_2 + +yeccpars2_86(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_86(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_87/7}). +-compile({nowarn_unused_function, yeccpars2_87/7}). +yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_87_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_88: see yeccpars2_2 + +%% yeccpars2_89: see yeccpars2_2 + +%% yeccpars2_90: see yeccpars2_2 + +%% yeccpars2_91: see yeccpars2_2 + +%% yeccpars2_92: see yeccpars2_2 + +%% yeccpars2_93: see yeccpars2_2 + +%% yeccpars2_94: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_95/7}). +-compile({nowarn_unused_function, yeccpars2_95/7}). +yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_95_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_96: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_97/7}). +-compile({nowarn_unused_function, yeccpars2_97/7}). +yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_97_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_98: see yeccpars2_2 + +%% yeccpars2_99: see yeccpars2_2 + +%% yeccpars2_100: see yeccpars2_2 + +%% yeccpars2_101: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_102/7}). +-compile({nowarn_unused_function, yeccpars2_102/7}). +yeccpars2_102(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 163, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 164, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 165, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 166, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 167, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 168, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_102(_, _, _, _, T, _, _) -> + yeccerror(T). + +%% yeccpars2_103: see yeccpars2_2 + +%% yeccpars2_104: see yeccpars2_2 + +%% yeccpars2_105: see yeccpars2_2 + +%% yeccpars2_106: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_107/7}). +-compile({nowarn_unused_function, yeccpars2_107/7}). +yeccpars2_107(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 145, Ss, Stack, T, Ts, Tzr); +yeccpars2_107(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_107_(Stack), + yeccgoto_dot_op(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_108/7}). +-compile({nowarn_unused_function, yeccpars2_108/7}). +yeccpars2_108(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 144, Ss, Stack, T, Ts, Tzr); +yeccpars2_108(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_108_(Stack), + yeccgoto_and_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_109/7}). +-compile({nowarn_unused_function, yeccpars2_109/7}). +yeccpars2_109(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 143, Ss, Stack, T, Ts, Tzr); +yeccpars2_109(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_109_(Stack), + yeccgoto_arrow_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_110/7}). +-compile({nowarn_unused_function, yeccpars2_110/7}). +yeccpars2_110(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 142, Ss, Stack, T, Ts, Tzr); +yeccpars2_110(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_110_(Stack), + yeccgoto_comp_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_111/7}). +-compile({nowarn_unused_function, yeccpars2_111/7}). +yeccpars2_111(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 141, Ss, Stack, T, Ts, Tzr); +yeccpars2_111(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_111_(Stack), + yeccgoto_concat_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_112/7}). +-compile({nowarn_unused_function, yeccpars2_112/7}). +yeccpars2_112(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_112_(Stack), + yeccgoto_dot_call_identifier(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_113/7}). +-compile({nowarn_unused_function, yeccpars2_113/7}). +yeccpars2_113(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 140, Ss, Stack, T, Ts, Tzr); +yeccpars2_113(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_113_(Stack), + yeccgoto_dual_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_114/7}). +-compile({nowarn_unused_function, yeccpars2_114/7}). +yeccpars2_114(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 139, Ss, Stack, T, Ts, Tzr); +yeccpars2_114(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_114_(Stack), + yeccgoto_in_match_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_115/7}). +-compile({nowarn_unused_function, yeccpars2_115/7}). +yeccpars2_115(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 138, Ss, Stack, T, Ts, Tzr); +yeccpars2_115(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_115_(Stack), + yeccgoto_in_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_116/7}). +-compile({nowarn_unused_function, yeccpars2_116/7}). +yeccpars2_116(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 137, Ss, Stack, T, Ts, Tzr); +yeccpars2_116(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_116_(Stack), + yeccgoto_match_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_117/7}). +-compile({nowarn_unused_function, yeccpars2_117/7}). +yeccpars2_117(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 136, Ss, Stack, T, Ts, Tzr); +yeccpars2_117(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_117_(Stack), + yeccgoto_mult_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_118/7}). +-compile({nowarn_unused_function, yeccpars2_118/7}). +yeccpars2_118(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 135, Ss, Stack, T, Ts, Tzr); +yeccpars2_118(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_118_(Stack), + yeccgoto_or_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_119/7}). +-compile({nowarn_unused_function, yeccpars2_119/7}). +yeccpars2_119(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 134, Ss, Stack, T, Ts, Tzr); +yeccpars2_119(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_119_(Stack), + yeccgoto_pipe_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_120/7}). +-compile({nowarn_unused_function, yeccpars2_120/7}). +yeccpars2_120(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 133, Ss, Stack, T, Ts, Tzr); +yeccpars2_120(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_120_(Stack), + yeccgoto_power_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_121/7}). +-compile({nowarn_unused_function, yeccpars2_121/7}). +yeccpars2_121(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 132, Ss, Stack, T, Ts, Tzr); +yeccpars2_121(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_121_(Stack), + yeccgoto_range_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_122/7}). +-compile({nowarn_unused_function, yeccpars2_122/7}). +yeccpars2_122(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 131, Ss, Stack, T, Ts, Tzr); +yeccpars2_122(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_122_(Stack), + yeccgoto_rel_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_123/7}). +-compile({nowarn_unused_function, yeccpars2_123/7}). +yeccpars2_123(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 130, Ss, Stack, T, Ts, Tzr); +yeccpars2_123(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_123_(Stack), + yeccgoto_ternary_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_124/7}). +-compile({nowarn_unused_function, yeccpars2_124/7}). +yeccpars2_124(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 129, Ss, Stack, T, Ts, Tzr); +yeccpars2_124(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_124_(Stack), + yeccgoto_type_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_125/7}). +-compile({nowarn_unused_function, yeccpars2_125/7}). +yeccpars2_125(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 128, Ss, Stack, T, Ts, Tzr); +yeccpars2_125(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_125_(Stack), + yeccgoto_when_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_126/7}). +-compile({nowarn_unused_function, yeccpars2_126/7}). +yeccpars2_126(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 127, Ss, Stack, T, Ts, Tzr); +yeccpars2_126(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_126_(Stack), + yeccgoto_xor_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_127/7}). +-compile({nowarn_unused_function, yeccpars2_127/7}). +yeccpars2_127(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_127_(Stack), + yeccgoto_xor_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_128/7}). +-compile({nowarn_unused_function, yeccpars2_128/7}). +yeccpars2_128(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_128_(Stack), + yeccgoto_when_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_129/7}). +-compile({nowarn_unused_function, yeccpars2_129/7}). +yeccpars2_129(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_129_(Stack), + yeccgoto_type_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_130/7}). +-compile({nowarn_unused_function, yeccpars2_130/7}). +yeccpars2_130(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_130_(Stack), + yeccgoto_ternary_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_131/7}). +-compile({nowarn_unused_function, yeccpars2_131/7}). +yeccpars2_131(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_131_(Stack), + yeccgoto_rel_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_132/7}). +-compile({nowarn_unused_function, yeccpars2_132/7}). +yeccpars2_132(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_132_(Stack), + yeccgoto_range_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_133/7}). +-compile({nowarn_unused_function, yeccpars2_133/7}). +yeccpars2_133(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_133_(Stack), + yeccgoto_power_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_134/7}). +-compile({nowarn_unused_function, yeccpars2_134/7}). +yeccpars2_134(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_134_(Stack), + yeccgoto_pipe_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_135/7}). +-compile({nowarn_unused_function, yeccpars2_135/7}). +yeccpars2_135(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_135_(Stack), + yeccgoto_or_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_136/7}). +-compile({nowarn_unused_function, yeccpars2_136/7}). +yeccpars2_136(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_136_(Stack), + yeccgoto_mult_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_137/7}). +-compile({nowarn_unused_function, yeccpars2_137/7}). +yeccpars2_137(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_137_(Stack), + yeccgoto_match_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_138/7}). +-compile({nowarn_unused_function, yeccpars2_138/7}). +yeccpars2_138(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_138_(Stack), + yeccgoto_in_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_139/7}). +-compile({nowarn_unused_function, yeccpars2_139/7}). +yeccpars2_139(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_139_(Stack), + yeccgoto_in_match_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_140/7}). +-compile({nowarn_unused_function, yeccpars2_140/7}). +yeccpars2_140(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_140_(Stack), + yeccgoto_dual_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_141/7}). +-compile({nowarn_unused_function, yeccpars2_141/7}). +yeccpars2_141(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_141_(Stack), + yeccgoto_concat_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_142/7}). +-compile({nowarn_unused_function, yeccpars2_142/7}). +yeccpars2_142(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_142_(Stack), + yeccgoto_comp_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_143/7}). +-compile({nowarn_unused_function, yeccpars2_143/7}). +yeccpars2_143(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_143_(Stack), + yeccgoto_arrow_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_144/7}). +-compile({nowarn_unused_function, yeccpars2_144/7}). +yeccpars2_144(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_144_(Stack), + yeccgoto_and_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_145/7}). +-compile({nowarn_unused_function, yeccpars2_145/7}). +yeccpars2_145(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_145_(Stack), + yeccgoto_dot_op(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_146/7}). +-compile({nowarn_unused_function, yeccpars2_146/7}). +yeccpars2_146(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_146(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_146_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_147/7}). +-compile({nowarn_unused_function, yeccpars2_147/7}). +yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_147_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_148/7}). +-compile({nowarn_unused_function, yeccpars2_148/7}). +yeccpars2_148(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_148(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_148_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_149/7}). +-compile({nowarn_unused_function, yeccpars2_149/7}). +yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_149_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_150/7}). +-compile({nowarn_unused_function, yeccpars2_150/7}). +yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_150_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_151/7}). +-compile({nowarn_unused_function, yeccpars2_151/7}). +yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_151_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_152/7}). +-compile({nowarn_unused_function, yeccpars2_152/7}). +yeccpars2_152(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_152(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_152_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_153/7}). +-compile({nowarn_unused_function, yeccpars2_153/7}). +yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_153_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_154/7}). +-compile({nowarn_unused_function, yeccpars2_154/7}). +yeccpars2_154(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_154_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_155/7}). +-compile({nowarn_unused_function, yeccpars2_155/7}). +yeccpars2_155(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_155(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_155_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_156/7}). +-compile({nowarn_unused_function, yeccpars2_156/7}). +yeccpars2_156(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_156(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_156_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_157/7}). +-compile({nowarn_unused_function, yeccpars2_157/7}). +yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_157_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_158/7}). +-compile({nowarn_unused_function, yeccpars2_158/7}). +yeccpars2_158(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_158(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_158_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_159/7}). +-compile({nowarn_unused_function, yeccpars2_159/7}). +yeccpars2_159(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_159(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_159(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_159(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_159(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_159(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_159_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_160/7}). +-compile({nowarn_unused_function, yeccpars2_160/7}). +yeccpars2_160(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_160_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_161/7}). +-compile({nowarn_unused_function, yeccpars2_161/7}). +yeccpars2_161(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_161(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_161_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_162(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_162(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_162(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_162(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_162(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 175, Ss, Stack, T, Ts, Tzr); +yeccpars2_162(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_163/7}). +-compile({nowarn_unused_function, yeccpars2_163/7}). +yeccpars2_163(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_163_(Stack), + yeccgoto_dot_alias(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_164/7}). +-compile({nowarn_unused_function, yeccpars2_164/7}). +yeccpars2_164(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_164_(Stack), + yeccgoto_dot_bracket_identifier(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_165/7}). +-compile({nowarn_unused_function, yeccpars2_165/7}). +yeccpars2_165(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_165_(Stack), + yeccgoto_dot_do_identifier(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_166/7}). +-compile({nowarn_unused_function, yeccpars2_166/7}). +yeccpars2_166(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_166_(Stack), + yeccgoto_dot_identifier(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_167/7}). +-compile({nowarn_unused_function, yeccpars2_167/7}). +yeccpars2_167(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_167_(Stack), + yeccgoto_dot_op_identifier(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_168/7}). +-compile({nowarn_unused_function, yeccpars2_168/7}). +yeccpars2_168(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_168_(Stack), + yeccgoto_dot_paren_identifier(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_169/7}). +-compile({nowarn_unused_function, yeccpars2_169/7}). +yeccpars2_169(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_169(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_169_(Stack), + yeccgoto_container_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_170/7}). +-compile({nowarn_unused_function, yeccpars2_170/7}). +yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_170_(Stack), + yeccgoto_container_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_171/7}). +-compile({nowarn_unused_function, yeccpars2_171/7}). +yeccpars2_171(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_171(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_171_(Stack), + yeccgoto_container_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_172/7}). +-compile({nowarn_unused_function, yeccpars2_172/7}). +yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_172_(Stack), + yeccgoto_container_args_base(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_173/7}). +-compile({nowarn_unused_function, yeccpars2_173/7}). +yeccpars2_173(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 180, Ss, Stack, T, Ts, Tzr); +yeccpars2_173(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_173_(Stack), + yeccgoto_container_args(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_174/7}). +-compile({nowarn_unused_function, yeccpars2_174/7}). +yeccpars2_174(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr); +yeccpars2_174(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr); +yeccpars2_174(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_175/7}). +-compile({nowarn_unused_function, yeccpars2_175/7}). +yeccpars2_175(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_175_(Stack), + yeccgoto_dot_alias(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_176/7}). +-compile({nowarn_unused_function, yeccpars2_176/7}). +yeccpars2_176(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_,_|Nss] = Ss, + NewStack = yeccpars2_176_(Stack), + yeccgoto_dot_alias(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_177/7}). +-compile({nowarn_unused_function, yeccpars2_177/7}). +yeccpars2_177(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 179, Ss, Stack, T, Ts, Tzr); +yeccpars2_177(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_178/7}). +-compile({nowarn_unused_function, yeccpars2_178/7}). +yeccpars2_178(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_178_(Stack), + yeccgoto_close_curly(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_179/7}). +-compile({nowarn_unused_function, yeccpars2_179/7}). +yeccpars2_179(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_179_(Stack), + yeccgoto_close_curly(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_180/7}). +-compile({nowarn_unused_function, yeccpars2_180/7}). +yeccpars2_180(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_180(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_180_(Stack), + yeccgoto_container_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_181: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_182/7}). +-compile({nowarn_unused_function, yeccpars2_182/7}). +yeccpars2_182(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_182_(Stack), + yeccgoto_container_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_183/7}). +-compile({nowarn_unused_function, yeccpars2_183/7}). +yeccpars2_183(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 191, Ss, Stack, T, Ts, Tzr); +yeccpars2_183(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_183_(Stack), + yeccgoto_kw_data(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_184/7}). +-compile({nowarn_unused_function, yeccpars2_184/7}). +yeccpars2_184(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_184_(Stack), + yeccgoto_container_args_base(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_185/7}). +-compile({nowarn_unused_function, yeccpars2_185/7}). +yeccpars2_185(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 190, Ss, Stack, T, Ts, Tzr); +yeccpars2_185(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_185_(Stack), + yeccgoto_kw_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_186/7}). +-compile({nowarn_unused_function, yeccpars2_186/7}). +yeccpars2_186(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 189, Ss, Stack, T, Ts, Tzr); +yeccpars2_186(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_186_(Stack), + yeccgoto_kw_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_187/7}). +-compile({nowarn_unused_function, yeccpars2_187/7}). +yeccpars2_187(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 188, Ss, Stack, T, Ts, Tzr); +yeccpars2_187(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_187_(Stack), + yeccgoto_kw_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_188/7}). +-compile({nowarn_unused_function, yeccpars2_188/7}). +yeccpars2_188(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_188_(Stack), + yeccgoto_kw_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_189/7}). +-compile({nowarn_unused_function, yeccpars2_189/7}). +yeccpars2_189(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_189_(Stack), + yeccgoto_kw_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_190/7}). +-compile({nowarn_unused_function, yeccpars2_190/7}). +yeccpars2_190(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_190_(Stack), + yeccgoto_kw_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_191/7}). +-compile({nowarn_unused_function, yeccpars2_191/7}). +yeccpars2_191(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_191(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_191_(Stack), + yeccgoto_kw_data(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_192(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_192(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_192(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr); +yeccpars2_192(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_192(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_193/7}). +-compile({nowarn_unused_function, yeccpars2_193/7}). +yeccpars2_193(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_193(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_193_(Stack), + yeccgoto_kw_data(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_194: see yeccpars2_2 + +yeccpars2_195(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_195(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_196/7}). +-compile({nowarn_unused_function, yeccpars2_196/7}). +yeccpars2_196(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_196(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_196_(Stack), + yeccgoto_no_parens_zero_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_197/7}). +-compile({nowarn_unused_function, yeccpars2_197/7}). +yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_197_(Stack), + yeccgoto_no_parens_zero_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_198: see yeccpars2_29 + +%% yeccpars2_199: see yeccpars2_192 + +%% yeccpars2_200: see yeccpars2_192 + +-dialyzer({nowarn_function, yeccpars2_201/7}). +-compile({nowarn_unused_function, yeccpars2_201/7}). +yeccpars2_201(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_201(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_201_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_202/7}). +-compile({nowarn_unused_function, yeccpars2_202/7}). +yeccpars2_202(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_202(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_202_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_203: see yeccpars2_192 + +%% yeccpars2_204: see yeccpars2_192 + +%% yeccpars2_205: see yeccpars2_192 + +%% yeccpars2_206: see yeccpars2_192 + +%% yeccpars2_207: see yeccpars2_192 + +%% yeccpars2_208: see yeccpars2_192 + +%% yeccpars2_209: see yeccpars2_192 + +%% yeccpars2_210: see yeccpars2_192 + +%% yeccpars2_211: see yeccpars2_192 + +%% yeccpars2_212: see yeccpars2_192 + +%% yeccpars2_213: see yeccpars2_192 + +%% yeccpars2_214: see yeccpars2_192 + +%% yeccpars2_215: see yeccpars2_192 + +%% yeccpars2_216: see yeccpars2_192 + +%% yeccpars2_217: see yeccpars2_192 + +%% yeccpars2_218: see yeccpars2_192 + +%% yeccpars2_219: see yeccpars2_192 + +%% yeccpars2_220: see yeccpars2_192 + +-dialyzer({nowarn_function, yeccpars2_221/7}). +-compile({nowarn_unused_function, yeccpars2_221/7}). +yeccpars2_221(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_221(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_221_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_222/7}). +-compile({nowarn_unused_function, yeccpars2_222/7}). +yeccpars2_222(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_222(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_222_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_223/7}). +-compile({nowarn_unused_function, yeccpars2_223/7}). +yeccpars2_223(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_223(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_223_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_224/7}). +-compile({nowarn_unused_function, yeccpars2_224/7}). +yeccpars2_224(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_224(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_224_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_225/7}). +-compile({nowarn_unused_function, yeccpars2_225/7}). +yeccpars2_225(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_225(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_225(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_225(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_225(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_225_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_226/7}). +-compile({nowarn_unused_function, yeccpars2_226/7}). +yeccpars2_226(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_226(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_226_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_227/7}). +-compile({nowarn_unused_function, yeccpars2_227/7}). +yeccpars2_227(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_227(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_227_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_228/7}). +-compile({nowarn_unused_function, yeccpars2_228/7}). +yeccpars2_228(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_228(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_228_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_229/7}). +-compile({nowarn_unused_function, yeccpars2_229/7}). +yeccpars2_229(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_229(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_229(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_229(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_229_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_230/7}). +-compile({nowarn_unused_function, yeccpars2_230/7}). +yeccpars2_230(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_230(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_230_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_231/7}). +-compile({nowarn_unused_function, yeccpars2_231/7}). +yeccpars2_231(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_231(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_231_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_232/7}). +-compile({nowarn_unused_function, yeccpars2_232/7}). +yeccpars2_232(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_232(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_232(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_232_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_233/7}). +-compile({nowarn_unused_function, yeccpars2_233/7}). +yeccpars2_233(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_233(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_233_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_234/7}). +-compile({nowarn_unused_function, yeccpars2_234/7}). +yeccpars2_234(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_234(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_234_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_235/7}). +-compile({nowarn_unused_function, yeccpars2_235/7}). +yeccpars2_235(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_235(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_235_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_236/7}). +-compile({nowarn_unused_function, yeccpars2_236/7}). +yeccpars2_236(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_236(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_236_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_237/7}). +-compile({nowarn_unused_function, yeccpars2_237/7}). +yeccpars2_237(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_237(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_237_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_238/7}). +-compile({nowarn_unused_function, yeccpars2_238/7}). +yeccpars2_238(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_238(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_238_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_239/7}). +-compile({nowarn_unused_function, yeccpars2_239/7}). +yeccpars2_239(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_239_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_240: see yeccpars2_30 + +-dialyzer({nowarn_function, yeccpars2_241/7}). +-compile({nowarn_unused_function, yeccpars2_241/7}). +yeccpars2_241(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_241(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 244, Ss, Stack, T, Ts, Tzr); +yeccpars2_241(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_241_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_242: see yeccpars2_86 + +-dialyzer({nowarn_function, yeccpars2_243/7}). +-compile({nowarn_unused_function, yeccpars2_243/7}). +yeccpars2_243(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_243_(Stack), + yeccgoto_bracket_at_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_244/7}). +-compile({nowarn_unused_function, yeccpars2_244/7}). +yeccpars2_244(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_244_(Stack), + yeccgoto_sub_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_245/7}). +-compile({nowarn_unused_function, yeccpars2_245/7}). +yeccpars2_245(S, ']', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 249, Ss, Stack, T, Ts, Tzr); +yeccpars2_245(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 250, Ss, Stack, T, Ts, Tzr); +yeccpars2_245(_, _, _, _, T, _, _) -> + yeccerror(T). + +yeccpars2_246(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 248, Ss, Stack, T, Ts, Tzr); +yeccpars2_246(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_245(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_247/7}). +-compile({nowarn_unused_function, yeccpars2_247/7}). +yeccpars2_247(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_247_(Stack), + yeccgoto_bracket_arg(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_248(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_248(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_248(S, ']', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 249, Ss, Stack, T, Ts, Tzr); +yeccpars2_248(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_248(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 250, Ss, Stack, T, Ts, Tzr); +yeccpars2_248(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_248(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_249/7}). +-compile({nowarn_unused_function, yeccpars2_249/7}). +yeccpars2_249(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_249_(Stack), + yeccgoto_close_bracket(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_250/7}). +-compile({nowarn_unused_function, yeccpars2_250/7}). +yeccpars2_250(S, ']', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 251, Ss, Stack, T, Ts, Tzr); +yeccpars2_250(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_251/7}). +-compile({nowarn_unused_function, yeccpars2_251/7}). +yeccpars2_251(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_251_(Stack), + yeccgoto_close_bracket(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_252: see yeccpars2_245 + +-dialyzer({nowarn_function, yeccpars2_253/7}). +-compile({nowarn_unused_function, yeccpars2_253/7}). +yeccpars2_253(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_253_(Stack), + yeccgoto_bracket_arg(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_254/7}). +-compile({nowarn_unused_function, yeccpars2_254/7}). +yeccpars2_254(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_,_|Nss] = Ss, + NewStack = yeccpars2_254_(Stack), + yeccgoto_bracket_arg(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_255/7}). +-compile({nowarn_unused_function, yeccpars2_255/7}). +yeccpars2_255(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_255_(Stack), + yeccgoto_bracket_arg(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_256/7}). +-compile({nowarn_unused_function, yeccpars2_256/7}). +yeccpars2_256(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_256_(Stack), + yeccgoto_bracket_at_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_257/7}). +-compile({nowarn_unused_function, yeccpars2_257/7}). +yeccpars2_257(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_257(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_257_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_258(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 268, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_258(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_259/7}). +-compile({nowarn_unused_function, yeccpars2_259/7}). +yeccpars2_259(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_259(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_259_(Stack), + yeccgoto_parens_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_260/7}). +-compile({nowarn_unused_function, yeccpars2_260/7}). +yeccpars2_260(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_260_(Stack), + yeccgoto_parens_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_261/7}). +-compile({nowarn_unused_function, yeccpars2_261/7}). +yeccpars2_261(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_261(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_261_(Stack), + yeccgoto_call_args_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_262/7}). +-compile({nowarn_unused_function, yeccpars2_262/7}). +yeccpars2_262(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_262(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_262(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_262_(Stack), + yeccgoto_call_args_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_263/7}). +-compile({nowarn_unused_function, yeccpars2_263/7}). +yeccpars2_263(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_263(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_263_(Stack), + yeccgoto_call_args_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_264/7}). +-compile({nowarn_unused_function, yeccpars2_264/7}). +yeccpars2_264(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_264(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_264(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_265/7}). +-compile({nowarn_unused_function, yeccpars2_265/7}). +yeccpars2_265(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 278, Ss, Stack, T, Ts, Tzr); +yeccpars2_265(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_265_(Stack), + yeccgoto_kw_call(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_266/7}). +-compile({nowarn_unused_function, yeccpars2_266/7}). +yeccpars2_266(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_266_(Stack), + yeccgoto_call_args_parens_base(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_267(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 271, Ss, Stack, T, Ts, Tzr); +yeccpars2_267(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_264(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_268/7}). +-compile({nowarn_unused_function, yeccpars2_268/7}). +yeccpars2_268(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_268_(Stack), + yeccgoto_call_args_parens(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_269/7}). +-compile({nowarn_unused_function, yeccpars2_269/7}). +yeccpars2_269(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_269_(Stack), + yeccgoto_call_args_parens(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_270/7}). +-compile({nowarn_unused_function, yeccpars2_270/7}). +yeccpars2_270(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_270_(Stack), + yeccgoto_close_paren(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_271: see yeccpars2_86 + +-dialyzer({nowarn_function, yeccpars2_272/7}). +-compile({nowarn_unused_function, yeccpars2_272/7}). +yeccpars2_272(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 273, Ss, Stack, T, Ts, Tzr); +yeccpars2_272(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_273/7}). +-compile({nowarn_unused_function, yeccpars2_273/7}). +yeccpars2_273(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_273_(Stack), + yeccgoto_close_paren(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_274/7}). +-compile({nowarn_unused_function, yeccpars2_274/7}). +yeccpars2_274(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_274_(Stack), + yeccgoto_call_args_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_275: see yeccpars2_264 + +-dialyzer({nowarn_function, yeccpars2_276/7}). +-compile({nowarn_unused_function, yeccpars2_276/7}). +yeccpars2_276(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_276_(Stack), + yeccgoto_call_args_parens_base(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_277/7}). +-compile({nowarn_unused_function, yeccpars2_277/7}). +yeccpars2_277(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_,_|Nss] = Ss, + NewStack = yeccpars2_277_(Stack), + yeccgoto_call_args_parens(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_278/7}). +-compile({nowarn_unused_function, yeccpars2_278/7}). +yeccpars2_278(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 201, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_278(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_278_(Stack), + yeccgoto_kw_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_279/7}). +-compile({nowarn_unused_function, yeccpars2_279/7}). +yeccpars2_279(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_279(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_279_(Stack), + yeccgoto_kw_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_280/7}). +-compile({nowarn_unused_function, yeccpars2_280/7}). +yeccpars2_280(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_280_(Stack), + yeccgoto_call_args_parens(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_281/7}). +-compile({nowarn_unused_function, yeccpars2_281/7}). +yeccpars2_281(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_281_(Stack), + yeccgoto_call_args_parens(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_282/7}). +-compile({nowarn_unused_function, yeccpars2_282/7}). +yeccpars2_282(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_282(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_282_(Stack), + yeccgoto_call_args_no_parens_one(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_283(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_283(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_283(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr); +yeccpars2_283(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_283(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_284/7}). +-compile({nowarn_unused_function, yeccpars2_284/7}). +yeccpars2_284(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_284_(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_285/7}). +-compile({nowarn_unused_function, yeccpars2_285/7}). +yeccpars2_285(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 287, Ss, Stack, T, Ts, Tzr); +yeccpars2_285(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_285_(Stack), + yeccgoto_call_args_no_parens_kw(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_286/7}). +-compile({nowarn_unused_function, yeccpars2_286/7}). +yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_286_(Stack), + yeccgoto_call_args_no_parens_one(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_287: see yeccpars2_195 + +-dialyzer({nowarn_function, yeccpars2_288/7}). +-compile({nowarn_unused_function, yeccpars2_288/7}). +yeccpars2_288(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_288(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_288_(Stack), + yeccgoto_call_args_no_parens_kw(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_289/7}). +-compile({nowarn_unused_function, yeccpars2_289/7}). +yeccpars2_289(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_289_(Stack), + yeccgoto_call_args_no_parens_kw(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_290: see yeccpars2_283 + +-dialyzer({nowarn_function, yeccpars2_291/7}). +-compile({nowarn_unused_function, yeccpars2_291/7}). +yeccpars2_291(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_291_(Stack), + yeccgoto_call_args_no_parens_kw_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_292/7}). +-compile({nowarn_unused_function, yeccpars2_292/7}). +yeccpars2_292(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_292(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_292_(Stack), + yeccgoto_call_args_no_parens_kw_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_293: see yeccpars2_26 + +-dialyzer({nowarn_function, yeccpars2_294/7}). +-compile({nowarn_unused_function, yeccpars2_294/7}). +yeccpars2_294(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_294(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_294_(Stack), + yeccgoto_no_parens_zero_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_295: see yeccpars2_283 + +%% yeccpars2_296: see yeccpars2_283 + +-dialyzer({nowarn_function, yeccpars2_297/7}). +-compile({nowarn_unused_function, yeccpars2_297/7}). +yeccpars2_297(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_297(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_297_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_298/7}). +-compile({nowarn_unused_function, yeccpars2_298/7}). +yeccpars2_298(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_298_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_299/7}). +-compile({nowarn_unused_function, yeccpars2_299/7}). +yeccpars2_299(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_299(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_299_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_300: see yeccpars2_283 + +%% yeccpars2_301: see yeccpars2_26 + +%% yeccpars2_302: see yeccpars2_283 + +%% yeccpars2_303: see yeccpars2_283 + +%% yeccpars2_304: see yeccpars2_283 + +%% yeccpars2_305: see yeccpars2_283 + +%% yeccpars2_306: see yeccpars2_283 + +%% yeccpars2_307: see yeccpars2_283 + +%% yeccpars2_308: see yeccpars2_283 + +%% yeccpars2_309: see yeccpars2_283 + +%% yeccpars2_310: see yeccpars2_283 + +%% yeccpars2_311: see yeccpars2_283 + +%% yeccpars2_312: see yeccpars2_283 + +%% yeccpars2_313: see yeccpars2_283 + +%% yeccpars2_314: see yeccpars2_283 + +%% yeccpars2_315: see yeccpars2_283 + +%% yeccpars2_316: see yeccpars2_283 + +%% yeccpars2_317: see yeccpars2_283 + +-dialyzer({nowarn_function, yeccpars2_318/7}). +-compile({nowarn_unused_function, yeccpars2_318/7}). +yeccpars2_318(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_318(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_318_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_319/7}). +-compile({nowarn_unused_function, yeccpars2_319/7}). +yeccpars2_319(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_319(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_319_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_320/7}). +-compile({nowarn_unused_function, yeccpars2_320/7}). +yeccpars2_320(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_320(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_320_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_321/7}). +-compile({nowarn_unused_function, yeccpars2_321/7}). +yeccpars2_321(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_321(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_321_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_322/7}). +-compile({nowarn_unused_function, yeccpars2_322/7}). +yeccpars2_322(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_322_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_323/7}). +-compile({nowarn_unused_function, yeccpars2_323/7}). +yeccpars2_323(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_323(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_323(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_323(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_323(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_323_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_324/7}). +-compile({nowarn_unused_function, yeccpars2_324/7}). +yeccpars2_324(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_324_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_325/7}). +-compile({nowarn_unused_function, yeccpars2_325/7}). +yeccpars2_325(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_325(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_325_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_326/7}). +-compile({nowarn_unused_function, yeccpars2_326/7}). +yeccpars2_326(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_326_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_327/7}). +-compile({nowarn_unused_function, yeccpars2_327/7}). +yeccpars2_327(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_327(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_327_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_328/7}). +-compile({nowarn_unused_function, yeccpars2_328/7}). +yeccpars2_328(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_328_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_329/7}). +-compile({nowarn_unused_function, yeccpars2_329/7}). +yeccpars2_329(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_329(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_329_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_330/7}). +-compile({nowarn_unused_function, yeccpars2_330/7}). +yeccpars2_330(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_330_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_331/7}). +-compile({nowarn_unused_function, yeccpars2_331/7}). +yeccpars2_331(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_331(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_331(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_331(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_331_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_332/7}). +-compile({nowarn_unused_function, yeccpars2_332/7}). +yeccpars2_332(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_332_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_333/7}). +-compile({nowarn_unused_function, yeccpars2_333/7}). +yeccpars2_333(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_333(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_333_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_334/7}). +-compile({nowarn_unused_function, yeccpars2_334/7}). +yeccpars2_334(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_334_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_335/7}). +-compile({nowarn_unused_function, yeccpars2_335/7}). +yeccpars2_335(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_335(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_335_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_336/7}). +-compile({nowarn_unused_function, yeccpars2_336/7}). +yeccpars2_336(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_336_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_337/7}). +-compile({nowarn_unused_function, yeccpars2_337/7}). +yeccpars2_337(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_337(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_337(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_337_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_338/7}). +-compile({nowarn_unused_function, yeccpars2_338/7}). +yeccpars2_338(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_338_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_339/7}). +-compile({nowarn_unused_function, yeccpars2_339/7}). +yeccpars2_339(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_339(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_339_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_340/7}). +-compile({nowarn_unused_function, yeccpars2_340/7}). +yeccpars2_340(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_340_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_341/7}). +-compile({nowarn_unused_function, yeccpars2_341/7}). +yeccpars2_341(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_341(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_341_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_342/7}). +-compile({nowarn_unused_function, yeccpars2_342/7}). +yeccpars2_342(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_342_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_343/7}). +-compile({nowarn_unused_function, yeccpars2_343/7}). +yeccpars2_343(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_343(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_343_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_344/7}). +-compile({nowarn_unused_function, yeccpars2_344/7}). +yeccpars2_344(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_344_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_345/7}). +-compile({nowarn_unused_function, yeccpars2_345/7}). +yeccpars2_345(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_345(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_345_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_346/7}). +-compile({nowarn_unused_function, yeccpars2_346/7}). +yeccpars2_346(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_346_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_347/7}). +-compile({nowarn_unused_function, yeccpars2_347/7}). +yeccpars2_347(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_347(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_347_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_348/7}). +-compile({nowarn_unused_function, yeccpars2_348/7}). +yeccpars2_348(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_348_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_349/7}). +-compile({nowarn_unused_function, yeccpars2_349/7}). +yeccpars2_349(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_349_(Stack), + yeccgoto_no_parens_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_350/7}). +-compile({nowarn_unused_function, yeccpars2_350/7}). +yeccpars2_350(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_350(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_350_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_351/7}). +-compile({nowarn_unused_function, yeccpars2_351/7}). +yeccpars2_351(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_351_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_352/7}). +-compile({nowarn_unused_function, yeccpars2_352/7}). +yeccpars2_352(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_352_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_353/7}). +-compile({nowarn_unused_function, yeccpars2_353/7}). +yeccpars2_353(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_353_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_354/7}). +-compile({nowarn_unused_function, yeccpars2_354/7}). +yeccpars2_354(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_354(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_354_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_355: see yeccpars2_6 + +-dialyzer({nowarn_function, yeccpars2_356/7}). +-compile({nowarn_unused_function, yeccpars2_356/7}). +yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_356_(Stack), + yeccgoto_call_args_no_parens_ambig(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_357/7}). +-compile({nowarn_unused_function, yeccpars2_357/7}). +yeccpars2_357(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 367, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_357(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_357_(Stack), + yeccgoto_call_args_no_parens_one(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_358/7}). +-compile({nowarn_unused_function, yeccpars2_358/7}). +yeccpars2_358(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_358_(Stack), + yeccgoto_no_parens_many_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_359/7}). +-compile({nowarn_unused_function, yeccpars2_359/7}). +yeccpars2_359(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_359_(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_360/7}). +-compile({nowarn_unused_function, yeccpars2_360/7}). +yeccpars2_360(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 362, Ss, Stack, T, Ts, Tzr); +yeccpars2_360(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_360_(Stack), + yeccgoto_call_args_no_parens_many(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_361/7}). +-compile({nowarn_unused_function, yeccpars2_361/7}). +yeccpars2_361(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_361_(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_362: see yeccpars2_26 + +-dialyzer({nowarn_function, yeccpars2_363/7}). +-compile({nowarn_unused_function, yeccpars2_363/7}). +yeccpars2_363(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_363_(Stack), + yeccgoto_call_args_no_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_364/7}). +-compile({nowarn_unused_function, yeccpars2_364/7}). +yeccpars2_364(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_364(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_364_(Stack), + yeccgoto_call_args_no_parens_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_365/7}). +-compile({nowarn_unused_function, yeccpars2_365/7}). +yeccpars2_365(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_365_(Stack), + yeccgoto_call_args_no_parens_many(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_366/7}). +-compile({nowarn_unused_function, yeccpars2_366/7}). +yeccpars2_366(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_366_(Stack), + yeccgoto_call_args_no_parens_comma_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_367: see yeccpars2_26 + +-dialyzer({nowarn_function, yeccpars2_368/7}). +-compile({nowarn_unused_function, yeccpars2_368/7}). +yeccpars2_368(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_368_(Stack), + yeccgoto_call_args_no_parens_many(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_369/7}). +-compile({nowarn_unused_function, yeccpars2_369/7}). +yeccpars2_369(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_369_(Stack), + yeccgoto_call_args_no_parens_comma_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_370/7}). +-compile({nowarn_unused_function, yeccpars2_370/7}). +yeccpars2_370(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_370(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 410, Ss, Stack, T, Ts, Tzr); +yeccpars2_370(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_371/7}). +-compile({nowarn_unused_function, yeccpars2_371/7}). +yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_371_(Stack), + yeccgoto_stab_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_372/7}). +-compile({nowarn_unused_function, yeccpars2_372/7}). +yeccpars2_372(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_372(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_372_(Stack), + yeccgoto_stab_op_eol_and_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_373/7}). +-compile({nowarn_unused_function, yeccpars2_373/7}). +yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_373_(Stack), + yeccgoto_stab(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_374/7}). +-compile({nowarn_unused_function, yeccpars2_374/7}). +yeccpars2_374(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 407, Ss, Stack, T, Ts, Tzr); +yeccpars2_374(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_375/7}). +-compile({nowarn_unused_function, yeccpars2_375/7}). +yeccpars2_375(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_375(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_375(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_375_(Stack), + yeccgoto_stab_eoe(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_376: see yeccpars2_6 + +-dialyzer({nowarn_function, yeccpars2_377/7}). +-compile({nowarn_unused_function, yeccpars2_377/7}). +yeccpars2_377(_S, ')', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_377_)'(Stack), + yeccgoto_expr(hd(Ss), ')', Ss, NewStack, T, Ts, Tzr); +yeccpars2_377(_S, ';', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_377_;'(Stack), + yeccgoto_expr(hd(Ss), ';', Ss, NewStack, T, Ts, Tzr); +yeccpars2_377(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_377_block_identifier(Stack), + yeccgoto_expr(hd(Ss), 'block_identifier', Ss, NewStack, T, Ts, Tzr); +yeccpars2_377(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_377_end(Stack), + yeccgoto_expr(hd(Ss), 'end', Ss, NewStack, T, Ts, Tzr); +yeccpars2_377(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_377_eol(Stack), + yeccgoto_expr(hd(Ss), 'eol', Ss, NewStack, T, Ts, Tzr); +yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_377_(Stack), + yeccgoto_call_args_no_parens_ambig(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_378/7}). +-compile({nowarn_unused_function, yeccpars2_378/7}). +yeccpars2_378(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 367, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_378(_S, ')', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_378_)'(Stack), + yeccgoto_expr(hd(Ss), ')', Ss, NewStack, T, Ts, Tzr); +yeccpars2_378(_S, ';', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_378_;'(Stack), + yeccgoto_expr(hd(Ss), ';', Ss, NewStack, T, Ts, Tzr); +yeccpars2_378(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_378_block_identifier(Stack), + yeccgoto_expr(hd(Ss), 'block_identifier', Ss, NewStack, T, Ts, Tzr); +yeccpars2_378(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_378_end(Stack), + yeccgoto_expr(hd(Ss), 'end', Ss, NewStack, T, Ts, Tzr); +yeccpars2_378(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_378_eol(Stack), + yeccgoto_expr(hd(Ss), 'eol', Ss, NewStack, T, Ts, Tzr); +yeccpars2_378(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_378_(Stack), + yeccgoto_call_args_no_parens_one(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_379/7}). +-compile({nowarn_unused_function, yeccpars2_379/7}). +yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_379_(Stack), + yeccgoto_stab_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_380/7}). +-compile({nowarn_unused_function, yeccpars2_380/7}). +yeccpars2_380(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_380(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 398, Ss, Stack, T, Ts, Tzr); +yeccpars2_380(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_380_(Stack), + yeccgoto_access_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_381/7}). +-compile({nowarn_unused_function, yeccpars2_381/7}). +yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_381_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_382/7}). +-compile({nowarn_unused_function, yeccpars2_382/7}). +yeccpars2_382(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_382(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_382(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_382_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_383/7}). +-compile({nowarn_unused_function, yeccpars2_383/7}). +yeccpars2_383(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_383(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_383(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_383_(Stack), + yeccgoto_call_args_no_parens_one(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_384/7}). +-compile({nowarn_unused_function, yeccpars2_384/7}). +yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_384_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_385/7}). +-compile({nowarn_unused_function, yeccpars2_385/7}). +yeccpars2_385(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_385(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_386/7}). +-compile({nowarn_unused_function, yeccpars2_386/7}). +yeccpars2_386(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_386_(Stack), + yeccgoto_empty_paren(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_387(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_387(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_388/7}). +-compile({nowarn_unused_function, yeccpars2_388/7}). +yeccpars2_388(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 389, Ss, Stack, T, Ts, Tzr); +yeccpars2_388(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_388_(Stack), + yeccgoto_stab_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_389/7}). +-compile({nowarn_unused_function, yeccpars2_389/7}). +yeccpars2_389(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_389_(Stack), + yeccgoto_stab_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_390/7}). +-compile({nowarn_unused_function, yeccpars2_390/7}). +yeccpars2_390(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 393, Ss, Stack, T, Ts, Tzr); +yeccpars2_390(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_391/7}). +-compile({nowarn_unused_function, yeccpars2_391/7}). +yeccpars2_391(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_391_(Stack), + yeccgoto_access_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_392/7}). +-compile({nowarn_unused_function, yeccpars2_392/7}). +yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_392_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_393/7}). +-compile({nowarn_unused_function, yeccpars2_393/7}). +yeccpars2_393(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_393_(Stack), + yeccgoto_access_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_394/7}). +-compile({nowarn_unused_function, yeccpars2_394/7}). +yeccpars2_394(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_394_(Stack), + yeccgoto_stab_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_395/7}). +-compile({nowarn_unused_function, yeccpars2_395/7}). +yeccpars2_395(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_395_(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_396/7}). +-compile({nowarn_unused_function, yeccpars2_396/7}). +yeccpars2_396(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_396_(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_397/7}). +-compile({nowarn_unused_function, yeccpars2_397/7}). +yeccpars2_397(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_397_(Stack), + yeccgoto_stab_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_398: see yeccpars2_2 + +%% yeccpars2_399: see yeccpars2_385 + +-dialyzer({nowarn_function, yeccpars2_400/7}). +-compile({nowarn_unused_function, yeccpars2_400/7}). +yeccpars2_400(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_400_(Stack), + yeccgoto_stab_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_401/7}). +-compile({nowarn_unused_function, yeccpars2_401/7}). +yeccpars2_401(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_401(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_401(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_401_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_402/7}). +-compile({nowarn_unused_function, yeccpars2_402/7}). +yeccpars2_402(S, ')', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 270, Ss, Stack, T, Ts, Tzr); +yeccpars2_402(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 272, Ss, Stack, T, Ts, Tzr); +yeccpars2_402(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_402_(Stack), + yeccgoto_call_args_no_parens_one(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_403/7}). +-compile({nowarn_unused_function, yeccpars2_403/7}). +yeccpars2_403(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_403_(Stack), + yeccgoto_stab_parens_many(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_404/7}). +-compile({nowarn_unused_function, yeccpars2_404/7}). +yeccpars2_404(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_404_(Stack), + yeccgoto_stab_parens_many(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_405/7}). +-compile({nowarn_unused_function, yeccpars2_405/7}). +yeccpars2_405(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_405(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_405_(Stack), + yeccgoto_stab_eoe(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_406/7}). +-compile({nowarn_unused_function, yeccpars2_406/7}). +yeccpars2_406(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_406_(Stack), + yeccgoto_stab(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_407/7}). +-compile({nowarn_unused_function, yeccpars2_407/7}). +yeccpars2_407(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_407_(Stack), + yeccgoto_access_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_408/7}). +-compile({nowarn_unused_function, yeccpars2_408/7}). +yeccpars2_408(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_408_(Stack), + yeccgoto_stab_op_eol_and_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_409/7}). +-compile({nowarn_unused_function, yeccpars2_409/7}). +yeccpars2_409(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_409_(Stack), + yeccgoto_stab_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_410: see yeccpars2_2 + +%% yeccpars2_411: see yeccpars2_385 + +-dialyzer({nowarn_function, yeccpars2_412/7}). +-compile({nowarn_unused_function, yeccpars2_412/7}). +yeccpars2_412(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_412_(Stack), + yeccgoto_stab_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_413/7}). +-compile({nowarn_unused_function, yeccpars2_413/7}). +yeccpars2_413(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_413_(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_414/7}). +-compile({nowarn_unused_function, yeccpars2_414/7}). +yeccpars2_414(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_414_(Stack), + yeccgoto_no_parens_many_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_415/7}). +-compile({nowarn_unused_function, yeccpars2_415/7}). +yeccpars2_415(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_415_(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_416/7}). +-compile({nowarn_unused_function, yeccpars2_416/7}). +yeccpars2_416(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_416_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_417/7}). +-compile({nowarn_unused_function, yeccpars2_417/7}). +yeccpars2_417(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_417(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_417(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_417_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_418/7}). +-compile({nowarn_unused_function, yeccpars2_418/7}). +yeccpars2_418(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_418_(Stack), + yeccgoto_kw_base(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_419/7}). +-compile({nowarn_unused_function, yeccpars2_419/7}). +yeccpars2_419(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_419(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_419(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_419_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_420/7}). +-compile({nowarn_unused_function, yeccpars2_420/7}). +yeccpars2_420(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_420_(Stack), + yeccgoto_kw_base(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_421/7}). +-compile({nowarn_unused_function, yeccpars2_421/7}). +yeccpars2_421(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_421(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_421(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_421_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_422/7}). +-compile({nowarn_unused_function, yeccpars2_422/7}). +yeccpars2_422(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_422(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_422(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_422(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_422(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_422_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_423/7}). +-compile({nowarn_unused_function, yeccpars2_423/7}). +yeccpars2_423(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_423(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_423_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_424/7}). +-compile({nowarn_unused_function, yeccpars2_424/7}). +yeccpars2_424(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_424(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_424_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_425/7}). +-compile({nowarn_unused_function, yeccpars2_425/7}). +yeccpars2_425(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_425(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_425_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_426/7}). +-compile({nowarn_unused_function, yeccpars2_426/7}). +yeccpars2_426(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_426(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_426_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_427/7}). +-compile({nowarn_unused_function, yeccpars2_427/7}). +yeccpars2_427(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_427(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_427_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_428/7}). +-compile({nowarn_unused_function, yeccpars2_428/7}). +yeccpars2_428(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_428(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_428_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_429/7}). +-compile({nowarn_unused_function, yeccpars2_429/7}). +yeccpars2_429(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_429(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_429_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_430/7}). +-compile({nowarn_unused_function, yeccpars2_430/7}). +yeccpars2_430(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_430(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_430(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_430(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_430_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_431/7}). +-compile({nowarn_unused_function, yeccpars2_431/7}). +yeccpars2_431(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_431(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_431_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_432/7}). +-compile({nowarn_unused_function, yeccpars2_432/7}). +yeccpars2_432(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_432(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_432_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_433/7}). +-compile({nowarn_unused_function, yeccpars2_433/7}). +yeccpars2_433(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_433(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_433_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_434/7}). +-compile({nowarn_unused_function, yeccpars2_434/7}). +yeccpars2_434(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_434(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_434_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_435/7}). +-compile({nowarn_unused_function, yeccpars2_435/7}). +yeccpars2_435(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_435_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_436/7}). +-compile({nowarn_unused_function, yeccpars2_436/7}). +yeccpars2_436(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_436(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_436(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_436_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_437/7}). +-compile({nowarn_unused_function, yeccpars2_437/7}). +yeccpars2_437(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_437(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_437(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_437(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_437(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_437(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_437_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_438/7}). +-compile({nowarn_unused_function, yeccpars2_438/7}). +yeccpars2_438(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_438(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_438_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_439/7}). +-compile({nowarn_unused_function, yeccpars2_439/7}). +yeccpars2_439(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_439(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_439_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_440/7}). +-compile({nowarn_unused_function, yeccpars2_440/7}). +yeccpars2_440(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_440(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_440_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_441/7}). +-compile({nowarn_unused_function, yeccpars2_441/7}). +yeccpars2_441(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_441(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_441(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_441(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_441(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_441(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_441(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_441_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_442/7}). +-compile({nowarn_unused_function, yeccpars2_442/7}). +yeccpars2_442(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_442(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_442_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_443/7}). +-compile({nowarn_unused_function, yeccpars2_443/7}). +yeccpars2_443(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_443(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_443_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_444/7}). +-compile({nowarn_unused_function, yeccpars2_444/7}). +yeccpars2_444(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_444(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_444_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_445/7}). +-compile({nowarn_unused_function, yeccpars2_445/7}). +yeccpars2_445(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_445(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_445_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_446/7}). +-compile({nowarn_unused_function, yeccpars2_446/7}). +yeccpars2_446(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_446(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_446_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_447/7}). +-compile({nowarn_unused_function, yeccpars2_447/7}). +yeccpars2_447(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_447(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_447(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_447(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_447(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_447(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_447(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_447_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_448/7}). +-compile({nowarn_unused_function, yeccpars2_448/7}). +yeccpars2_448(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_448(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_448_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_449/7}). +-compile({nowarn_unused_function, yeccpars2_449/7}). +yeccpars2_449(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_449_(Stack), + yeccgoto_unary_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_450/7}). +-compile({nowarn_unused_function, yeccpars2_450/7}). +yeccpars2_450(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_450_(Stack), + yeccgoto_capture_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_451/7}). +-compile({nowarn_unused_function, yeccpars2_451/7}). +yeccpars2_451(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_451_(Stack), + yeccgoto_access_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_452/7}). +-compile({nowarn_unused_function, yeccpars2_452/7}). +yeccpars2_452(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_452_(Stack), + yeccgoto_at_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_453/7}). +-compile({nowarn_unused_function, yeccpars2_453/7}). +yeccpars2_453(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_453_(Stack), + yeccgoto_open_bracket(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_454/7}). +-compile({nowarn_unused_function, yeccpars2_454/7}). +yeccpars2_454(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_454_(Stack), + yeccgoto_open_bit(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_455/7}). +-compile({nowarn_unused_function, yeccpars2_455/7}). +yeccpars2_455(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_455_(Stack), + yeccgoto_open_paren(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_456/7}). +-compile({nowarn_unused_function, yeccpars2_456/7}). +yeccpars2_456(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_456_(Stack), + yeccgoto_map_op(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_457: see yeccpars2_39 + +-dialyzer({nowarn_function, yeccpars2_458/7}). +-compile({nowarn_unused_function, yeccpars2_458/7}). +yeccpars2_458(_S, ',', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_458_,'(Stack), + yeccgoto_map_base_expr(hd(Ss), ',', Ss, NewStack, T, Ts, Tzr); +yeccpars2_458(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_458_eol(Stack), + yeccgoto_map_base_expr(hd(Ss), 'eol', Ss, NewStack, T, Ts, Tzr); +yeccpars2_458(_S, '{', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_458_{'(Stack), + yeccgoto_map_base_expr(hd(Ss), '{', Ss, NewStack, T, Ts, Tzr); +yeccpars2_458(_S, '}', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_458_}'(Stack), + yeccgoto_map_base_expr(hd(Ss), '}', Ss, NewStack, T, Ts, Tzr); +yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_458_(Stack), + yeccgoto_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +yeccpars2_459(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_459(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_459(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_459(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_459/7}). +-compile({nowarn_unused_function, yeccpars2_459/7}). +yeccpars2_cont_459(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_cont_459(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_460/7}). +-compile({nowarn_unused_function, yeccpars2_460/7}). +yeccpars2_460(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 467, Ss, Stack, T, Ts, Tzr); +yeccpars2_460(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_460(_, _, _, _, T, _, _) -> + yeccerror(T). + +%% yeccpars2_461: see yeccpars2_39 + +-dialyzer({nowarn_function, yeccpars2_462/7}). +-compile({nowarn_unused_function, yeccpars2_462/7}). +yeccpars2_462(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 462, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_462(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_462_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_463/7}). +-compile({nowarn_unused_function, yeccpars2_463/7}). +yeccpars2_463(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_463_(Stack), + yeccgoto_map_base_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_464/7}). +-compile({nowarn_unused_function, yeccpars2_464/7}). +yeccpars2_464(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_464_(Stack), + yeccgoto_map_base_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_465(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 484, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 485, Ss, Stack, T, Ts, Tzr); +yeccpars2_465(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_466/7}). +-compile({nowarn_unused_function, yeccpars2_466/7}). +yeccpars2_466(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_466_(Stack), + yeccgoto_map(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_467: see yeccpars2_16 + +-dialyzer({nowarn_function, yeccpars2_468/7}). +-compile({nowarn_unused_function, yeccpars2_468/7}). +yeccpars2_468(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_468_(Stack), + yeccgoto_map(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_469(S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 522, Ss, Stack, T, Ts, Tzr); +yeccpars2_469(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_459(S, Cat, Ss, Stack, T, Ts, Tzr). + +yeccpars2_470(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_470(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_470(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 488, Ss, Stack, T, Ts, Tzr); +yeccpars2_470(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_470(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +yeccpars2_471(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_471(S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 522, Ss, Stack, T, Ts, Tzr); +yeccpars2_471(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_471(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_459(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_472/7}). +-compile({nowarn_unused_function, yeccpars2_472/7}). +yeccpars2_472(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_472_(Stack), + yeccgoto_map_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_473/7}). +-compile({nowarn_unused_function, yeccpars2_473/7}). +yeccpars2_473(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_473_(Stack), + yeccgoto_assoc_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_474: see yeccpars2_174 + +%% yeccpars2_475: see yeccpars2_26 + +-dialyzer({nowarn_function, yeccpars2_476/7}). +-compile({nowarn_unused_function, yeccpars2_476/7}). +yeccpars2_476(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 297, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_476(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_476_(Stack), + yeccgoto_no_parens_zero_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_477: see yeccpars2_2 + +%% yeccpars2_478: see yeccpars2_470 + +%% yeccpars2_479: see yeccpars2_174 + +yeccpars2_480(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 551, Ss, Stack, T, Ts, Tzr); +yeccpars2_480(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_481/7}). +-compile({nowarn_unused_function, yeccpars2_481/7}). +yeccpars2_481(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_481_(Stack), + yeccgoto_assoc_base(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_482/7}). +-compile({nowarn_unused_function, yeccpars2_482/7}). +yeccpars2_482(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 497, Ss, Stack, T, Ts, Tzr); +yeccpars2_482(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_482_(Stack), + yeccgoto_assoc(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_483: see yeccpars2_174 + +-dialyzer({nowarn_function, yeccpars2_484/7}). +-compile({nowarn_unused_function, yeccpars2_484/7}). +yeccpars2_484(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 488, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_484(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_484_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_485/7}). +-compile({nowarn_unused_function, yeccpars2_485/7}). +yeccpars2_485(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_485_(Stack), + yeccgoto_map_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_486: see yeccpars2_470 + +%% yeccpars2_487: see yeccpars2_470 + +-dialyzer({nowarn_function, yeccpars2_488/7}). +-compile({nowarn_unused_function, yeccpars2_488/7}). +yeccpars2_488(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 488, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_488(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_488_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_489/7}). +-compile({nowarn_unused_function, yeccpars2_489/7}). +yeccpars2_489(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_489_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_490/7}). +-compile({nowarn_unused_function, yeccpars2_490/7}). +yeccpars2_490(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_490_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_491/7}). +-compile({nowarn_unused_function, yeccpars2_491/7}). +yeccpars2_491(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_491_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_492/7}). +-compile({nowarn_unused_function, yeccpars2_492/7}). +yeccpars2_492(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_492_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_493/7}). +-compile({nowarn_unused_function, yeccpars2_493/7}). +yeccpars2_493(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_493(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_493(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_493_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_494/7}). +-compile({nowarn_unused_function, yeccpars2_494/7}). +yeccpars2_494(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_494_(Stack), + yeccgoto_map_base_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_495/7}). +-compile({nowarn_unused_function, yeccpars2_495/7}). +yeccpars2_495(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_495_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_496/7}). +-compile({nowarn_unused_function, yeccpars2_496/7}). +yeccpars2_496(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_496_(Stack), + yeccgoto_map_close(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_497/7}). +-compile({nowarn_unused_function, yeccpars2_497/7}). +yeccpars2_497(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 484, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_497(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_497_(Stack), + yeccgoto_assoc(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_498: see yeccpars2_469 + +%% yeccpars2_499: see yeccpars2_471 + +%% yeccpars2_500: see yeccpars2_174 + +-dialyzer({nowarn_function, yeccpars2_501/7}). +-compile({nowarn_unused_function, yeccpars2_501/7}). +yeccpars2_501(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_501_(Stack), + yeccgoto_assoc_base(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_502/7}). +-compile({nowarn_unused_function, yeccpars2_502/7}). +yeccpars2_502(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_502_(Stack), + yeccgoto_map_close(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_503(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_503(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_503(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 527, Ss, Stack, T, Ts, Tzr); +yeccpars2_503(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_503(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +%% yeccpars2_504: see yeccpars2_503 + +%% yeccpars2_505: see yeccpars2_503 + +%% yeccpars2_506: see yeccpars2_503 + +%% yeccpars2_507: see yeccpars2_503 + +%% yeccpars2_508: see yeccpars2_503 + +%% yeccpars2_509: see yeccpars2_503 + +%% yeccpars2_510: see yeccpars2_503 + +%% yeccpars2_511: see yeccpars2_503 + +%% yeccpars2_512: see yeccpars2_503 + +%% yeccpars2_513: see yeccpars2_503 + +%% yeccpars2_514: see yeccpars2_503 + +%% yeccpars2_515: see yeccpars2_503 + +%% yeccpars2_516: see yeccpars2_503 + +%% yeccpars2_517: see yeccpars2_503 + +%% yeccpars2_518: see yeccpars2_503 + +%% yeccpars2_519: see yeccpars2_503 + +%% yeccpars2_520: see yeccpars2_503 + +%% yeccpars2_521: see yeccpars2_503 + +-dialyzer({nowarn_function, yeccpars2_522/7}). +-compile({nowarn_unused_function, yeccpars2_522/7}). +yeccpars2_522(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 523, Ss, Stack, T, Ts, Tzr); +yeccpars2_522(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_522_(Stack), + yeccgoto_assoc_op_eol(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_523/7}). +-compile({nowarn_unused_function, yeccpars2_523/7}). +yeccpars2_523(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_523_(Stack), + yeccgoto_assoc_op_eol(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_524: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_525/7}). +-compile({nowarn_unused_function, yeccpars2_525/7}). +yeccpars2_525(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_525(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_525_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_526: see yeccpars2_2 + +-dialyzer({nowarn_function, yeccpars2_527/7}). +-compile({nowarn_unused_function, yeccpars2_527/7}). +yeccpars2_527(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_527(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_527_(Stack), + yeccgoto_sub_matched_expr(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_528/7}). +-compile({nowarn_unused_function, yeccpars2_528/7}). +yeccpars2_528(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_528(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_528_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_529/7}). +-compile({nowarn_unused_function, yeccpars2_529/7}). +yeccpars2_529(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_529(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_529_(Stack), + yeccgoto_assoc_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_530/7}). +-compile({nowarn_unused_function, yeccpars2_530/7}). +yeccpars2_530(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_530(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_530_(Stack), + yeccgoto_assoc_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_531/7}). +-compile({nowarn_unused_function, yeccpars2_531/7}). +yeccpars2_531(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_531(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_531_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_532/7}). +-compile({nowarn_unused_function, yeccpars2_532/7}). +yeccpars2_532(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_532(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_532_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_533/7}). +-compile({nowarn_unused_function, yeccpars2_533/7}). +yeccpars2_533(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_533(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_533(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_533(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_533(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_533_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_534/7}). +-compile({nowarn_unused_function, yeccpars2_534/7}). +yeccpars2_534(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_534(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_534_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_535/7}). +-compile({nowarn_unused_function, yeccpars2_535/7}). +yeccpars2_535(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_535(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_535_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_536/7}). +-compile({nowarn_unused_function, yeccpars2_536/7}). +yeccpars2_536(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_536(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_536_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_537/7}). +-compile({nowarn_unused_function, yeccpars2_537/7}). +yeccpars2_537(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_537(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_537(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_537(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_537_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_538/7}). +-compile({nowarn_unused_function, yeccpars2_538/7}). +yeccpars2_538(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_538(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_538_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_539/7}). +-compile({nowarn_unused_function, yeccpars2_539/7}). +yeccpars2_539(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_539(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_539_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_540/7}). +-compile({nowarn_unused_function, yeccpars2_540/7}). +yeccpars2_540(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_540(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_540(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_540_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_541/7}). +-compile({nowarn_unused_function, yeccpars2_541/7}). +yeccpars2_541(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_541(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_541_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_542/7}). +-compile({nowarn_unused_function, yeccpars2_542/7}). +yeccpars2_542(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_542(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_542_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_543/7}). +-compile({nowarn_unused_function, yeccpars2_543/7}). +yeccpars2_543(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_543(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_543_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_544/7}). +-compile({nowarn_unused_function, yeccpars2_544/7}). +yeccpars2_544(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_544(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_544_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_545/7}). +-compile({nowarn_unused_function, yeccpars2_545/7}). +yeccpars2_545(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_545(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_545_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_546/7}). +-compile({nowarn_unused_function, yeccpars2_546/7}). +yeccpars2_546(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_546(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_546_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_547: see yeccpars2_503 + +-dialyzer({nowarn_function, yeccpars2_548/7}). +-compile({nowarn_unused_function, yeccpars2_548/7}). +yeccpars2_548(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_548(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_548_(Stack), + yeccgoto_assoc_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_549/7}). +-compile({nowarn_unused_function, yeccpars2_549/7}). +yeccpars2_549(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 114, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 124, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 125, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_549(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_549_(Stack), + yeccgoto_assoc_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_550/7}). +-compile({nowarn_unused_function, yeccpars2_550/7}). +yeccpars2_550(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_550_(Stack), + yeccgoto_map_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_551(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 484, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 177, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 178, Ss, Stack, T, Ts, Tzr); +yeccpars2_551(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_552/7}). +-compile({nowarn_unused_function, yeccpars2_552/7}). +yeccpars2_552(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_552_(Stack), + yeccgoto_map_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_553/7}). +-compile({nowarn_unused_function, yeccpars2_553/7}). +yeccpars2_553(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_553_(Stack), + yeccgoto_map_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_554/7}). +-compile({nowarn_unused_function, yeccpars2_554/7}). +yeccpars2_554(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_554_(Stack), + yeccgoto_map_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_555/7}). +-compile({nowarn_unused_function, yeccpars2_555/7}). +yeccpars2_555(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_555(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_555_(Stack), + yeccgoto_matched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_556/7}). +-compile({nowarn_unused_function, yeccpars2_556/7}). +yeccpars2_556(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_556_(Stack), + yeccgoto_unmatched_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_557/7}). +-compile({nowarn_unused_function, yeccpars2_557/7}). +yeccpars2_557(_S, '$end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_$end'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '$end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, ')', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_)'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ')', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, ',', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_,'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ',', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, '.', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_.'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '.', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, ';', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_;'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ';', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, '>>', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_>>'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '>>', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, ']', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_]'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ']', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_and_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'and_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_arrow_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'arrow_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_assoc_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'assoc_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_block_identifier(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'block_identifier', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_comp_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'comp_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_concat_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'concat_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_dot_call_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'dot_call_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_dual_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'dual_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_end(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_eol(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'eol', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_in_match_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'in_match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_in_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'in_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_match_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_mult_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'mult_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_or_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'or_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_pipe_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'pipe_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_power_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'power_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_range_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'range_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_rel_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'rel_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_stab_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'stab_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_ternary_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'ternary_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_type_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'type_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_when_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'when_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_557_xor_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'xor_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, '}', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_557_}'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '}', Nss, NewStack, T, Ts, Tzr); +yeccpars2_557(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_557_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_558/7}). +-compile({nowarn_unused_function, yeccpars2_558/7}). +yeccpars2_558(S, 'do', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 561, Ss, Stack, T, Ts, Tzr); +yeccpars2_558(_, _, _, _, T, _, _) -> + yeccerror(T). + +yeccpars2_559(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 567, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'end', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 568, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_559(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_560/7}). +-compile({nowarn_unused_function, yeccpars2_560/7}). +yeccpars2_560(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_560_(Stack), + yeccgoto_block_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_561/7}). +-compile({nowarn_unused_function, yeccpars2_561/7}). +yeccpars2_561(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_561(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_561(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_561_(Stack), + yeccgoto_do_eoe(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_562/7}). +-compile({nowarn_unused_function, yeccpars2_562/7}). +yeccpars2_562(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_562_(Stack), + yeccgoto_do_eoe(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_563/7}). +-compile({nowarn_unused_function, yeccpars2_563/7}). +yeccpars2_563(S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 567, Ss, Stack, T, Ts, Tzr); +yeccpars2_563(S, 'end', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 574, Ss, Stack, T, Ts, Tzr); +yeccpars2_563(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_564/7}). +-compile({nowarn_unused_function, yeccpars2_564/7}). +yeccpars2_564(S, 'end', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 572, Ss, Stack, T, Ts, Tzr); +yeccpars2_564(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_565/7}). +-compile({nowarn_unused_function, yeccpars2_565/7}). +yeccpars2_565(S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 567, Ss, Stack, T, Ts, Tzr); +yeccpars2_565(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_565_(Stack), + yeccgoto_block_list(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_566/7}). +-compile({nowarn_unused_function, yeccpars2_566/7}). +yeccpars2_566(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 388, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_566(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_566_(Stack), + yeccgoto_block_item(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_567/7}). +-compile({nowarn_unused_function, yeccpars2_567/7}). +yeccpars2_567(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_567(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_567(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_567_(Stack), + yeccgoto_block_eoe(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_568/7}). +-compile({nowarn_unused_function, yeccpars2_568/7}). +yeccpars2_568(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_568_(Stack), + yeccgoto_do_block(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_569/7}). +-compile({nowarn_unused_function, yeccpars2_569/7}). +yeccpars2_569(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_569_(Stack), + yeccgoto_block_eoe(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_570/7}). +-compile({nowarn_unused_function, yeccpars2_570/7}). +yeccpars2_570(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_570_(Stack), + yeccgoto_block_item(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_571/7}). +-compile({nowarn_unused_function, yeccpars2_571/7}). +yeccpars2_571(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_571_(Stack), + yeccgoto_block_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_572/7}). +-compile({nowarn_unused_function, yeccpars2_572/7}). +yeccpars2_572(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_572_(Stack), + yeccgoto_do_block(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_573/7}). +-compile({nowarn_unused_function, yeccpars2_573/7}). +yeccpars2_573(S, 'end', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 575, Ss, Stack, T, Ts, Tzr); +yeccpars2_573(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_574/7}). +-compile({nowarn_unused_function, yeccpars2_574/7}). +yeccpars2_574(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_574_(Stack), + yeccgoto_do_block(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_575/7}). +-compile({nowarn_unused_function, yeccpars2_575/7}). +yeccpars2_575(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_575_(Stack), + yeccgoto_do_block(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_576/7}). +-compile({nowarn_unused_function, yeccpars2_576/7}). +yeccpars2_576(_S, '$end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_$end'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '$end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, ')', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_)'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ')', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, ',', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_,'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ',', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, '.', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_.'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '.', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, ';', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_;'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ';', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, '>>', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_>>'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '>>', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, ']', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_]'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), ']', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_and_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'and_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_arrow_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'arrow_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_assoc_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'assoc_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_block_identifier(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'block_identifier', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_comp_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'comp_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_concat_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'concat_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_dot_call_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'dot_call_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_dual_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'dual_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_end(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_eol(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'eol', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_in_match_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'in_match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_in_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'in_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_match_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_mult_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'mult_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_or_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'or_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_pipe_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'pipe_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_power_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'power_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_range_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'range_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_rel_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'rel_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_stab_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'stab_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_ternary_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'ternary_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_type_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'type_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_when_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'when_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_576_xor_op(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), 'xor_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, '}', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_576_}'(Stack), + yeccgoto_no_parens_one_expr(hd(Nss), '}', Nss, NewStack, T, Ts, Tzr); +yeccpars2_576(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_576_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +%% yeccpars2_577: see yeccpars2_558 + +-dialyzer({nowarn_function, yeccpars2_578/7}). +-compile({nowarn_unused_function, yeccpars2_578/7}). +yeccpars2_578(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_578_(Stack), + yeccgoto_block_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_579/7}). +-compile({nowarn_unused_function, yeccpars2_579/7}). +yeccpars2_579(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_579_(Stack), + yeccgoto_map_close(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_580(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 484, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_580(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_581/7}). +-compile({nowarn_unused_function, yeccpars2_581/7}). +yeccpars2_581(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 522, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_581(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_581_(Stack), + yeccgoto_unmatched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_582/7}). +-compile({nowarn_unused_function, yeccpars2_582/7}). +yeccpars2_582(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 522, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_582(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_582_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_583/7}). +-compile({nowarn_unused_function, yeccpars2_583/7}). +yeccpars2_583(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_583_(Stack), + yeccgoto_assoc_update_kw(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_584/7}). +-compile({nowarn_unused_function, yeccpars2_584/7}). +yeccpars2_584(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_584_(Stack), + yeccgoto_assoc_update(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +yeccpars2_585(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 488, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_585(S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_cont_2(S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_586/7}). +-compile({nowarn_unused_function, yeccpars2_586/7}). +yeccpars2_586(S, '.', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 107, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 108, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 109, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 522, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 110, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 111, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'dot_call_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 112, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 113, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 115, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 116, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 117, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 118, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 119, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 120, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 121, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 122, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 123, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 126, Ss, Stack, T, Ts, Tzr); +yeccpars2_586(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_586_(Stack), + yeccgoto_matched_op_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_587/7}). +-compile({nowarn_unused_function, yeccpars2_587/7}). +yeccpars2_587(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_587_(Stack), + yeccgoto_assoc_update_kw(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_588/7}). +-compile({nowarn_unused_function, yeccpars2_588/7}). +yeccpars2_588(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_588_(Stack), + yeccgoto_assoc_update(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_589/7}). +-compile({nowarn_unused_function, yeccpars2_589/7}). +yeccpars2_589(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_589_(Stack), + yeccgoto_bracket_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_590/7}). +-compile({nowarn_unused_function, yeccpars2_590/7}). +yeccpars2_590(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_590_(Stack), + yeccgoto_no_parens_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_591/7}). +-compile({nowarn_unused_function, yeccpars2_591/7}). +yeccpars2_591(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_591_(Stack), + yeccgoto_bracket_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_592/7}). +-compile({nowarn_unused_function, yeccpars2_592/7}). +yeccpars2_592(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_592(S, 'do', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 561, Ss, Stack, T, Ts, Tzr); +yeccpars2_592(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_592_(Stack), + yeccgoto_parens_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_593/7}). +-compile({nowarn_unused_function, yeccpars2_593/7}). +yeccpars2_593(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_593_(Stack), + yeccgoto_block_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_594/7}). +-compile({nowarn_unused_function, yeccpars2_594/7}). +yeccpars2_594(S, 'do', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 561, Ss, Stack, T, Ts, Tzr); +yeccpars2_594(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_594_(Stack), + yeccgoto_parens_call(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_595/7}). +-compile({nowarn_unused_function, yeccpars2_595/7}). +yeccpars2_595(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_,_|Nss] = Ss, + NewStack = yeccpars2_595_(Stack), + yeccgoto_block_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_596/7}). +-compile({nowarn_unused_function, yeccpars2_596/7}). +yeccpars2_596(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_596_(Stack), + yeccgoto_block_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_597/7}). +-compile({nowarn_unused_function, yeccpars2_597/7}). +yeccpars2_597(_S, '$end', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_$end'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), '$end', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, ')', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_)'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), ')', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, ',', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_,'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), ',', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, ';', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_;'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), ';', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, '>>', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_>>'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), '>>', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, ']', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_]'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), ']', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_and_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'and_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_arrow_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'arrow_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_assoc_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'assoc_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_block_identifier(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'block_identifier', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_comp_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'comp_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_concat_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'concat_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_dual_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'dual_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_end(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'end', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_eol(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'eol', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_in_match_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'in_match_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_in_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'in_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_match_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'match_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_mult_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'mult_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_or_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'or_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_pipe_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'pipe_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_power_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'power_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_range_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'range_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_rel_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'rel_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_stab_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'stab_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_ternary_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'ternary_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_type_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'type_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_when_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'when_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_xor_op(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), 'xor_op', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, '}', Ss, Stack, T, Ts, Tzr) -> + NewStack = 'yeccpars2_597_}'(Stack), + yeccgoto_call_args_no_parens_many_strict(hd(Ss), '}', Ss, NewStack, T, Ts, Tzr); +yeccpars2_597(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_597_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_598/7}). +-compile({nowarn_unused_function, yeccpars2_598/7}). +yeccpars2_598(_S, '$end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_$end'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), '$end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, ')', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_)'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ')', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, ',', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_,'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ',', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, ';', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_;'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ';', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, '>>', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_>>'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), '>>', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, ']', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_]'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ']', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_and_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'and_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_arrow_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'arrow_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_assoc_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'assoc_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_block_identifier(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'block_identifier', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_comp_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'comp_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_concat_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'concat_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_dual_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'dual_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_end(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_eol(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'eol', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_in_match_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'in_match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_in_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'in_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_match_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_mult_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'mult_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_or_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'or_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_pipe_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'pipe_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_power_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'power_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_range_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'range_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_rel_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'rel_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_stab_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'stab_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_ternary_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'ternary_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_type_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'type_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_when_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'when_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_598_xor_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'xor_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, '}', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_598_}'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), '}', Nss, NewStack, T, Ts, Tzr); +yeccpars2_598(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_598_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_599/7}). +-compile({nowarn_unused_function, yeccpars2_599/7}). +yeccpars2_599(_S, '$end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_$end'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), '$end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, ')', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_)'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ')', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, ',', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_,'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ',', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, ';', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_;'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ';', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, '>>', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_>>'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), '>>', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, ']', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_]'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), ']', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'and_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_and_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'and_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'arrow_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_arrow_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'arrow_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'assoc_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_assoc_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'assoc_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'block_identifier', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_block_identifier(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'block_identifier', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'comp_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_comp_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'comp_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'concat_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_concat_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'concat_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_dual_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'dual_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'end', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_end(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'end', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'eol', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_eol(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'eol', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'in_match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_in_match_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'in_match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'in_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_in_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'in_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'match_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_match_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'match_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'mult_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_mult_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'mult_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'or_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_or_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'or_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'pipe_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_pipe_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'pipe_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'power_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_power_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'power_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_range_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'range_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'rel_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_rel_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'rel_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'stab_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_stab_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'stab_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_ternary_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'ternary_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'type_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_type_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'type_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'when_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_when_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'when_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, 'xor_op', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_599_xor_op(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), 'xor_op', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, '}', Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = 'yeccpars2_599_}'(Stack), + yeccgoto_no_parens_one_ambig_expr(hd(Nss), '}', Nss, NewStack, T, Ts, Tzr); +yeccpars2_599(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_599_(Stack), + yeccgoto_call_args_no_parens_all(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_600/7}). +-compile({nowarn_unused_function, yeccpars2_600/7}). +yeccpars2_600(S, ';', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 42, Ss, Stack, T, Ts, Tzr); +yeccpars2_600(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 60, Ss, Stack, T, Ts, Tzr); +yeccpars2_600(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_600_(Stack), + yeccgoto_grammar(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_601/7}). +-compile({nowarn_unused_function, yeccpars2_601/7}). +yeccpars2_601(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_601(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_601_(Stack), + yeccgoto_grammar(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_602/7}). +-compile({nowarn_unused_function, yeccpars2_602/7}). +yeccpars2_602(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_602_(Stack), + yeccgoto_expr_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_603/7}). +-compile({nowarn_unused_function, yeccpars2_603/7}). +yeccpars2_603(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_603(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_603_(Stack), + yeccgoto_grammar(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_604/7}). +-compile({nowarn_unused_function, yeccpars2_604/7}). +yeccpars2_604(S, 'end', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 605, Ss, Stack, T, Ts, Tzr); +yeccpars2_604(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_605/7}). +-compile({nowarn_unused_function, yeccpars2_605/7}). +yeccpars2_605(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_605_(Stack), + yeccgoto_access_expr(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_606/7}). +-compile({nowarn_unused_function, yeccpars2_606/7}). +yeccpars2_606(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_606_(Stack), + yeccgoto_map(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_607/7}). +-compile({nowarn_unused_function, yeccpars2_607/7}). +yeccpars2_607(S, '>>', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 614, Ss, Stack, T, Ts, Tzr); +yeccpars2_607(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_608/7}). +-compile({nowarn_unused_function, yeccpars2_608/7}). +yeccpars2_608(S, '>>', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 611, Ss, Stack, T, Ts, Tzr); +yeccpars2_608(S, 'eol', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 612, Ss, Stack, T, Ts, Tzr); +yeccpars2_608(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_609/7}). +-compile({nowarn_unused_function, yeccpars2_609/7}). +yeccpars2_609(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_609_(Stack), + yeccgoto_bitstring(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_610/7}). +-compile({nowarn_unused_function, yeccpars2_610/7}). +yeccpars2_610(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_610_(Stack), + yeccgoto_bitstring(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_611/7}). +-compile({nowarn_unused_function, yeccpars2_611/7}). +yeccpars2_611(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_611_(Stack), + yeccgoto_close_bit(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_612/7}). +-compile({nowarn_unused_function, yeccpars2_612/7}). +yeccpars2_612(S, '>>', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 613, Ss, Stack, T, Ts, Tzr); +yeccpars2_612(_, _, _, _, T, _, _) -> + yeccerror(T). + +-dialyzer({nowarn_function, yeccpars2_613/7}). +-compile({nowarn_unused_function, yeccpars2_613/7}). +yeccpars2_613(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_613_(Stack), + yeccgoto_close_bit(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_614/7}). +-compile({nowarn_unused_function, yeccpars2_614/7}). +yeccpars2_614(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_614_(Stack), + yeccgoto_bitstring(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +%% yeccpars2_615: see yeccpars2_245 + +-dialyzer({nowarn_function, yeccpars2_616/7}). +-compile({nowarn_unused_function, yeccpars2_616/7}). +yeccpars2_616(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_616_(Stack), + yeccgoto_list_args(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_617/7}). +-compile({nowarn_unused_function, yeccpars2_617/7}). +yeccpars2_617(S, ',', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 619, Ss, Stack, T, Ts, Tzr); +yeccpars2_617(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + NewStack = yeccpars2_617_(Stack), + yeccgoto_list_args(hd(Ss), Cat, Ss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_618/7}). +-compile({nowarn_unused_function, yeccpars2_618/7}). +yeccpars2_618(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_618_(Stack), + yeccgoto_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_619/7}). +-compile({nowarn_unused_function, yeccpars2_619/7}). +yeccpars2_619(S, '%', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 39, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, '%{}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 40, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, '(', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 41, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, '<<', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 43, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, '[', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 44, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'alias', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 45, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'at_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 46, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'atom', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 47, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'atom_quoted', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 48, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'atom_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 49, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'atom_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 50, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'bin_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 51, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'bin_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 52, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'bracket_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 53, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'capture_int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 54, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'capture_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 55, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'char', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 56, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'do_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 57, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'dual_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 58, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'ellipsis_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 59, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'false', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 61, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'flt', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 62, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'fn', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 63, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 64, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'int', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 65, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'kw_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 185, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'kw_identifier_safe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 186, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'kw_identifier_unsafe', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 187, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'list_heredoc', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 66, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'list_string', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 67, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'nil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 68, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'op_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 69, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'paren_identifier', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 70, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'range_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 71, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'sigil', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 72, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'ternary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 73, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'true', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 74, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, 'unary_op', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 75, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(S, '{', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 76, Ss, Stack, T, Ts, Tzr); +yeccpars2_619(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_619_(Stack), + yeccgoto_list_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_620/7}). +-compile({nowarn_unused_function, yeccpars2_620/7}). +yeccpars2_620(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_620_(Stack), + yeccgoto_list_args(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_621/7}). +-compile({nowarn_unused_function, yeccpars2_621/7}). +yeccpars2_621(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_621_(Stack), + yeccgoto_list(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_622/7}). +-compile({nowarn_unused_function, yeccpars2_622/7}). +yeccpars2_622(S, '}', Ss, Stack, T, Ts, Tzr) -> + yeccpars1(S, 626, Ss, Stack, T, Ts, Tzr); +yeccpars2_622(_, _, _, _, T, _, _) -> + yeccerror(T). + +%% yeccpars2_623: see yeccpars2_174 + +-dialyzer({nowarn_function, yeccpars2_624/7}). +-compile({nowarn_unused_function, yeccpars2_624/7}). +yeccpars2_624(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_|Nss] = Ss, + NewStack = yeccpars2_624_(Stack), + yeccgoto_tuple(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_625/7}). +-compile({nowarn_unused_function, yeccpars2_625/7}). +yeccpars2_625(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_625_(Stack), + yeccgoto_tuple(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccpars2_626/7}). +-compile({nowarn_unused_function, yeccpars2_626/7}). +yeccpars2_626(_S, Cat, Ss, Stack, T, Ts, Tzr) -> + [_,_|Nss] = Ss, + NewStack = yeccpars2_626_(Stack), + yeccgoto_tuple(hd(Nss), Cat, Nss, NewStack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_access_expr/7}). +-compile({nowarn_unused_function, yeccgoto_access_expr/7}). +yeccgoto_access_expr(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_241(241, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_access_expr(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_38(38, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_and_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_and_op_eol/7}). +yeccgoto_and_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(317, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(220, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(521, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_and_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(106, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_arrow_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_arrow_op_eol/7}). +yeccgoto_arrow_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(316, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(219, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(520, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_arrow_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(105, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_assoc/7}). +-compile({nowarn_unused_function, yeccgoto_assoc/7}). +yeccgoto_assoc(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(483, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(483, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_assoc_base/7}). +-compile({nowarn_unused_function, yeccgoto_assoc_base/7}). +yeccgoto_assoc_base(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_482(482, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_base(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_482(482, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_assoc_expr/7}). +-compile({nowarn_unused_function, yeccgoto_assoc_expr/7}). +yeccgoto_assoc_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_481(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_501(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_481(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_584(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_588(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_assoc_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_assoc_op_eol/7}). +yeccgoto_assoc_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(547, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(519, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(547, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(519, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(547, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(519, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_assoc_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(519, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_assoc_update/7}). +-compile({nowarn_unused_function, yeccgoto_assoc_update/7}). +yeccgoto_assoc_update(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_480(480, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_assoc_update_kw/7}). +-compile({nowarn_unused_function, yeccgoto_assoc_update_kw/7}). +yeccgoto_assoc_update_kw(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(479, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_at_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_at_op_eol/7}). +yeccgoto_at_op_eol(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(461, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(200, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(461, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(461, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(461, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(478, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(296, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(478, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(526, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(478, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(478, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(487, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_at_op_eol(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(37, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_bitstring/7}). +-compile({nowarn_unused_function, yeccgoto_bitstring/7}). +yeccgoto_bitstring(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bitstring(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_36(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_block_eoe/7}). +-compile({nowarn_unused_function, yeccgoto_block_eoe/7}). +yeccgoto_block_eoe(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_566(566, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_eoe(563, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_566(566, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_eoe(565, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_566(566, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_block_expr/7}). +-compile({nowarn_unused_function, yeccgoto_block_expr/7}). +yeccgoto_block_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_35(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_block_item/7}). +-compile({nowarn_unused_function, yeccgoto_block_item/7}). +yeccgoto_block_item(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_565(565, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_item(563, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_565(565, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_item(565, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_565(565, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_block_list/7}). +-compile({nowarn_unused_function, yeccgoto_block_list/7}). +yeccgoto_block_list(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_564(564, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_list(563, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_573(573, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_block_list(565=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_571(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_bracket_arg/7}). +-compile({nowarn_unused_function, yeccgoto_bracket_arg/7}). +yeccgoto_bracket_arg(30=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_591(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_arg(38=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_589(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_arg(240=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_256(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_arg(241=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_243(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_bracket_at_expr/7}). +-compile({nowarn_unused_function, yeccgoto_bracket_at_expr/7}). +yeccgoto_bracket_at_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_at_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_34(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_bracket_expr/7}). +-compile({nowarn_unused_function, yeccgoto_bracket_expr/7}). +yeccgoto_bracket_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_bracket_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_33(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_all/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_all/7}). +yeccgoto_call_args_no_parens_all(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_558(577, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_558(558, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_558(577, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_558(558, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_all(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(385, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_ambig/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_ambig/7}). +yeccgoto_call_args_no_parens_ambig(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_599(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_598(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_415(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_361(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_ambig(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_384(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_comma_expr/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_comma_expr/7}). +yeccgoto_call_args_no_parens_comma_expr(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_comma_expr(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_360(360, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_expr/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_expr/7}). +yeccgoto_call_args_no_parens_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_366(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_369(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_kw/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_kw/7}). +yeccgoto_call_args_no_parens_kw(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_348(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_289(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_348(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_383(383, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_365(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_368(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_402(402, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_286(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_kw_expr/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_kw_expr/7}). +yeccgoto_call_args_no_parens_kw_expr(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_kw_expr(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_285(285, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_many/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_many/7}). +yeccgoto_call_args_no_parens_many(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_597(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_597(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_359(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_359(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_382(382, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_401(401, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_392(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_many_strict/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_many_strict/7}). +yeccgoto_call_args_no_parens_many_strict(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_414(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many_strict(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_358(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many_strict(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_414(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_many_strict(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_358(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_no_parens_one/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_no_parens_one/7}). +yeccgoto_call_args_no_parens_one(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_576(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_557(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_413(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_284(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_413(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_284(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_576(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_557(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_no_parens_one(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_381(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_parens/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_parens/7}). +yeccgoto_call_args_parens(29, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_592(592, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_parens(198, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_259(259, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_parens(259=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_260(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_parens(592, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_594(594, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_parens_base/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_parens_base/7}). +yeccgoto_call_args_parens_base(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_267(267, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_call_args_parens_expr/7}). +-compile({nowarn_unused_function, yeccgoto_call_args_parens_expr/7}). +yeccgoto_call_args_parens_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_266(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_call_args_parens_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_276(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_capture_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_capture_op_eol/7}). +yeccgoto_capture_op_eol(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(199, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(295, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(477, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_capture_op_eol(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(32, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_close_bit/7}). +-compile({nowarn_unused_function, yeccgoto_close_bit/7}). +yeccgoto_close_bit(608=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_610(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_close_bracket/7}). +-compile({nowarn_unused_function, yeccgoto_close_bracket/7}). +yeccgoto_close_bracket(245=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_255(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_bracket(246=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_247(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_bracket(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_253(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_bracket(252=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_254(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_bracket(615=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_621(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_close_curly/7}). +-compile({nowarn_unused_function, yeccgoto_close_curly/7}). +yeccgoto_close_curly(174=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_176(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(474=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_579(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(479=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_554(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(480=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_550(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(483=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_496(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(500=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_502(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_553(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_curly(623=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_625(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_close_paren/7}). +-compile({nowarn_unused_function, yeccgoto_close_paren/7}). +yeccgoto_close_paren(262=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_281(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(264=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_280(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(267=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_269(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(275=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_277(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(382=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_396(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(383=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_395(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_391(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(401=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_404(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_close_paren(402=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_403(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_comp_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_comp_op_eol/7}). +yeccgoto_comp_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(315, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(218, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(518, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_comp_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(104, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_concat_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_concat_op_eol/7}). +yeccgoto_concat_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(314, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(217, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(517, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_concat_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(103, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_container_args/7}). +-compile({nowarn_unused_function, yeccgoto_container_args/7}). +yeccgoto_container_args(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(623, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_608(608, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(174, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_245(252, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_container_args_base/7}). +-compile({nowarn_unused_function, yeccgoto_container_args_base/7}). +yeccgoto_container_args_base(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_173(173, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args_base(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_617(617, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args_base(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_173(173, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args_base(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_173(173, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_args_base(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_173(173, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_container_expr/7}). +-compile({nowarn_unused_function, yeccgoto_container_expr/7}). +yeccgoto_container_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_184(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_420(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_418(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_246(246, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_172(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_container_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_184(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_do_block/7}). +-compile({nowarn_unused_function, yeccgoto_do_block/7}). +yeccgoto_do_block(28=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_596(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_block(558=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_560(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_block(577=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_578(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_block(592=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_593(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_block(594=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_595(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_do_eoe/7}). +-compile({nowarn_unused_function, yeccgoto_do_eoe/7}). +yeccgoto_do_eoe(28, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_559(559, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_eoe(558, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_559(559, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_eoe(577, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_559(559, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_eoe(592, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_559(559, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_do_eoe(594, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_559(559, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_alias/7}). +-compile({nowarn_unused_function, yeccgoto_dot_alias/7}). +yeccgoto_dot_alias(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_alias(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_31(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_bracket_identifier/7}). +-compile({nowarn_unused_function, yeccgoto_dot_bracket_identifier/7}). +yeccgoto_dot_bracket_identifier(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(240, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_bracket_identifier(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_30(30, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_call_identifier/7}). +-compile({nowarn_unused_function, yeccgoto_dot_call_identifier/7}). +yeccgoto_dot_call_identifier(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(198, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_call_identifier(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_29(29, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_do_identifier/7}). +-compile({nowarn_unused_function, yeccgoto_dot_do_identifier/7}). +yeccgoto_dot_do_identifier(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_197(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_do_identifier(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_28(28, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_identifier/7}). +-compile({nowarn_unused_function, yeccgoto_dot_identifier/7}). +yeccgoto_dot_identifier(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_196(196, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_294(294, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_476(476, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_identifier(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_27(27, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_op/7}). +-compile({nowarn_unused_function, yeccgoto_dot_op/7}). +yeccgoto_dot_op(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_102(102, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_op_identifier/7}). +-compile({nowarn_unused_function, yeccgoto_dot_op_identifier/7}). +yeccgoto_dot_op_identifier(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_195(195, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(293, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(475, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_op_identifier(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(26, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dot_paren_identifier/7}). +-compile({nowarn_unused_function, yeccgoto_dot_paren_identifier/7}). +yeccgoto_dot_paren_identifier(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dot_paren_identifier(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_25(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_dual_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_dual_op_eol/7}). +yeccgoto_dual_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(313, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(216, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(516, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_dual_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(101, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_empty_paren/7}). +-compile({nowarn_unused_function, yeccgoto_empty_paren/7}). +yeccgoto_empty_paren(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_380(380, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_empty_paren(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_24(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_eoe/7}). +-compile({nowarn_unused_function, yeccgoto_eoe/7}). +yeccgoto_eoe(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_23(23, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_eoe(21, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_603(603, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_eoe(63=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_80(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_eoe(375, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_405(405, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_eoe(561=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_562(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_eoe(567=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_569(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_eoe(600, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_601(601, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_expr/7}). +-compile({nowarn_unused_function, yeccgoto_expr/7}). +yeccgoto_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_22(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_495(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_22(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_556(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_491(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_84(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_408(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(399, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_385(411, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_495(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_556(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_491(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_84(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_495(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_491(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_84(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_495(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_491(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_84(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_379(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_602(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_602(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_expr_list/7}). +-compile({nowarn_unused_function, yeccgoto_expr_list/7}). +yeccgoto_expr_list(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_21(21, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_expr_list(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_600(600, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_fn_eoe/7}). +-compile({nowarn_unused_function, yeccgoto_fn_eoe/7}). +yeccgoto_fn_eoe(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_fn_eoe(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_20(20, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_grammar/7}). +-compile({nowarn_unused_function, yeccgoto_grammar/7}). +yeccgoto_grammar(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_19(19, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_in_match_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_in_match_op_eol/7}). +yeccgoto_in_match_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(312, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(215, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(515, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_match_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(100, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_in_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_in_op_eol/7}). +yeccgoto_in_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(311, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(214, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(514, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_in_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(99, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_kw_base/7}). +-compile({nowarn_unused_function, yeccgoto_kw_base/7}). +yeccgoto_kw_base(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_265(265, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_265(265, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_base(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_183(183, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_kw_call/7}). +-compile({nowarn_unused_function, yeccgoto_kw_call/7}). +yeccgoto_kw_call(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_264(264, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_call(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_264(275, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_kw_data/7}). +-compile({nowarn_unused_function, yeccgoto_kw_data/7}). +yeccgoto_kw_data(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_622(622, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_616(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_607(607, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_182(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_245(245, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(474, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(500, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_174(474, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_583(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_587(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_data(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_620(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_kw_eol/7}). +-compile({nowarn_unused_function, yeccgoto_kw_eol/7}). +yeccgoto_kw_eol(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(194, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(194, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(283, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_kw_eol(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(181, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_list/7}). +-compile({nowarn_unused_function, yeccgoto_list/7}). +yeccgoto_list(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_list(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_18(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_list_args/7}). +-compile({nowarn_unused_function, yeccgoto_list_args/7}). +yeccgoto_list_args(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_245(615, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_map/7}). +-compile({nowarn_unused_function, yeccgoto_map/7}). +yeccgoto_map(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_17(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_map_args/7}). +-compile({nowarn_unused_function, yeccgoto_map_args/7}). +yeccgoto_map_args(16=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_606(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_args(460=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_466(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_args(467=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_468(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_map_base_expr/7}). +-compile({nowarn_unused_function, yeccgoto_map_base_expr/7}). +yeccgoto_map_base_expr(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_460(460, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_494(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_464(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_463(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_473(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_494(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_464(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_463(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_494(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_464(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_463(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_473(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_473(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_473(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_base_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_473(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_map_close/7}). +-compile({nowarn_unused_function, yeccgoto_map_close/7}). +yeccgoto_map_close(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_472(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_close(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_552(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_map_op/7}). +-compile({nowarn_unused_function, yeccgoto_map_op/7}). +yeccgoto_map_op(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_map_op(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_16(16, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_match_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_match_op_eol/7}). +yeccgoto_match_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(310, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(213, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(513, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_match_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(98, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_matched_expr/7}). +-compile({nowarn_unused_function, yeccgoto_matched_expr/7}). +yeccgoto_matched_expr(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_493(493, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_555(555, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_490(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_459(459, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_83(83, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_448(448, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_446(446, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_444(444, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_442(442, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_440(440, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_438(438, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_436(436, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_434(434, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_432(432, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_430(430, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_428(428, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_426(426, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_424(424, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_422(422, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_161(161, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_158(158, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_155(155, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_148(148, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_193(193, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_419(419, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_282(282, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_282(282, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_257(257, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_239(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_202(202, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_238(238, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_237(237, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_236(236, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_235(235, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_234(234, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_233(233, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_232(232, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_231(231, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_230(230, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_229(229, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_228(228, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_227(227, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_226(226, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_225(225, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_224(224, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_223(223, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_222(222, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_221(221, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_263(263, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_263(263, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_279(279, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_292(292, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_288(288, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_417(417, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_354(354, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_352(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_299(299, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_350(350, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_347(347, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_345(345, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_343(343, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_341(341, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_339(339, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_337(337, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_335(335, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_333(333, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_331(331, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_329(329, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_327(327, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_325(325, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_323(323, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_321(321, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_320(320, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_319(319, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_318(318, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_364(364, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_364(364, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_419(419, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_239(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_202(202, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_471(471, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_493(493, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_357(357, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_555(555, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_490(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_83(83, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_493(493, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_490(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_83(83, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_471(499, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_546(546, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_545(545, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_544(544, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_543(543, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_542(542, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_541(541, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_540(540, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_539(539, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_538(538, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_537(537, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_536(536, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_535(535, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_534(534, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_533(533, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_532(532, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_531(531, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_530(530, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_528(528, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_525(525, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_493(493, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_490(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_83(83, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_549(549, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_471(499, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_378(378, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_582(582, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_586(586, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_15(15, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_expr(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_171(171, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_matched_op_expr/7}). +-compile({nowarn_unused_function, yeccgoto_matched_op_expr/7}). +yeccgoto_matched_op_expr(1=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(15=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(83=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(152=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(155=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(156=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(158=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(169=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(171=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(193=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(202=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(221=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(222=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(223=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(224=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(225=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(226=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(227=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(228=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(229=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(230=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(231=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(232=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(233=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(234=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(235=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(236=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(237=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(238=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(239=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(257=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(279=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(282=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(288=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(292=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(299=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(318=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(319=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(320=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(321=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(323=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(325=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(327=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(329=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(331=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(333=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(335=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(337=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(339=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(341=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(343=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(345=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(347=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(350=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(352=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(354=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(357=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(364=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(378=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(417=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(419=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(421=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(422=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(423=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(424=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(425=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(426=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(427=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(429=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(430=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(431=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(432=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(433=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(434=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(435=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(436=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(437=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(438=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(440=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(442=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(443=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(444=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(445=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(446=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(447=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(448=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(459=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(469=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(471=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(490=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(493=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(498=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(499=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(525=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(528=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(529=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(530=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(531=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(532=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(533=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(534=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(535=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(536=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(537=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(538=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(539=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(540=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(541=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(542=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(543=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(544=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(545=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(546=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(548=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(549=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(555=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(581=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_151(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(582=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_matched_op_expr(586=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_97(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_mult_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_mult_op_eol/7}). +yeccgoto_mult_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(309, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(212, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(512, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_mult_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(96, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_no_parens_expr/7}). +-compile({nowarn_unused_function, yeccgoto_no_parens_expr/7}). +yeccgoto_no_parens_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_492(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_590(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_489(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_82(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_349(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_346(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_344(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_342(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_340(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_338(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_336(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_334(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_332(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_330(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_328(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_326(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_324(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_322(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_160(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_154(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_262(262, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_274(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_291(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_416(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_353(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_351(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_298(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_349(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_346(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_344(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_342(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_340(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_338(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_336(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_334(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_332(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_330(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_328(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_326(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_324(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_322(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_160(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_157(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_154(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_147(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_363(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_363(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_356(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_492(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_489(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_82(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_377(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_334(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_14(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_170(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_no_parens_many_expr/7}). +-compile({nowarn_unused_function, yeccgoto_no_parens_many_expr/7}). +yeccgoto_no_parens_many_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_many_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_13(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_no_parens_one_ambig_expr/7}). +-compile({nowarn_unused_function, yeccgoto_no_parens_one_ambig_expr/7}). +yeccgoto_no_parens_one_ambig_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_ambig_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_12(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_no_parens_one_expr/7}). +-compile({nowarn_unused_function, yeccgoto_no_parens_one_expr/7}). +yeccgoto_no_parens_one_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_153(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_one_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_11(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_no_parens_op_expr/7}). +-compile({nowarn_unused_function, yeccgoto_no_parens_op_expr/7}). +yeccgoto_no_parens_op_expr(1=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(15=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(83=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(152=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(155=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(156=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(158=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(169=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(171=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(292=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(299=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(318=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(319=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(320=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(321=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(323=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(325=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(327=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(329=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(331=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(333=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(335=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(337=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(339=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(341=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(343=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(345=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(347=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(350=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(352=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(354=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(357=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(364=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(378=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(417=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(421=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(422=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(423=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(424=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(425=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(426=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(427=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(429=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(430=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(431=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(432=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(433=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(434=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(435=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(436=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(437=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(438=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(440=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(442=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(443=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(444=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(445=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(446=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(447=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(448=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(469=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(490=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(493=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(498=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(529=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(548=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(555=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(581=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_150(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_op_expr(586=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_95(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_no_parens_zero_expr/7}). +-compile({nowarn_unused_function, yeccgoto_no_parens_zero_expr/7}). +yeccgoto_no_parens_zero_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_no_parens_zero_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_10(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_open_bit/7}). +-compile({nowarn_unused_function, yeccgoto_open_bit/7}). +yeccgoto_open_bit(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bit(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_9(9, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_open_bracket/7}). +-compile({nowarn_unused_function, yeccgoto_open_bracket/7}). +yeccgoto_open_bracket(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(30, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(242, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(38, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(242, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(240, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(242, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(241, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(242, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_bracket(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_8(8, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_open_curly/7}). +-compile({nowarn_unused_function, yeccgoto_open_curly/7}). +yeccgoto_open_curly(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(16, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_465(465, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(102, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_162(162, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(460, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_465(465, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(467, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_465(465, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_curly(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_7(7, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_open_paren/7}). +-compile({nowarn_unused_function, yeccgoto_open_paren/7}). +yeccgoto_open_paren(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(355, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(355, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(29, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_258(258, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(198, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_258(258, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(259, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_258(258, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(355, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(355, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(376, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(592, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_258(258, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_open_paren(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_6(6, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_or_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_or_op_eol/7}). +yeccgoto_or_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(308, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(211, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(511, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_or_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(94, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_parens_call/7}). +-compile({nowarn_unused_function, yeccgoto_parens_call/7}). +yeccgoto_parens_call(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_parens_call(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_5(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_pipe_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_pipe_op_eol/7}). +yeccgoto_pipe_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(307, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(210, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_585(585, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_580(580, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(510, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_pipe_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(93, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_power_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_power_op_eol/7}). +yeccgoto_power_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(306, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(209, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(509, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_power_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(92, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_range_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_range_op_eol/7}). +yeccgoto_range_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(305, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(208, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(508, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_range_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(91, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_rel_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_rel_op_eol/7}). +yeccgoto_rel_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(304, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(207, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(507, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_rel_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(90, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_stab/7}). +-compile({nowarn_unused_function, yeccgoto_stab/7}). +yeccgoto_stab(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_375(375, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_stab_eoe/7}). +-compile({nowarn_unused_function, yeccgoto_stab_eoe/7}). +yeccgoto_stab_eoe(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_374(374, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_eoe(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_604(604, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_eoe(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_374(374, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_eoe(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_374(374, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_eoe(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_390(390, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_eoe(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_563(563, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_eoe(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_570(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_stab_expr/7}). +-compile({nowarn_unused_function, yeccgoto_stab_expr/7}). +yeccgoto_stab_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_406(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_373(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_stab_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_stab_op_eol/7}). +yeccgoto_stab_op_eol(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(370, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(380, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(385, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(399, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(411, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_372(372, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_stab_op_eol_and_expr/7}). +-compile({nowarn_unused_function, yeccgoto_stab_op_eol_and_expr/7}). +yeccgoto_stab_op_eol_and_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(370=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_409(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(380=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_397(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(385=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_394(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(399=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_400(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(411=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_412(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_op_eol_and_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_371(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_stab_parens_many/7}). +-compile({nowarn_unused_function, yeccgoto_stab_parens_many/7}). +yeccgoto_stab_parens_many(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_stab_parens_many(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_370(370, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_sub_matched_expr/7}). +-compile({nowarn_unused_function, yeccgoto_sub_matched_expr/7}). +yeccgoto_sub_matched_expr(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_458(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_sub_matched_expr(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_4(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_ternary_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_ternary_op_eol/7}). +yeccgoto_ternary_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(303, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(206, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(506, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_ternary_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(89, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_tuple/7}). +-compile({nowarn_unused_function, yeccgoto_tuple/7}). +yeccgoto_tuple(0=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(2=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(6=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(7=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(8=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(9=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(20=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(23=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(26=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(27=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(32=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(37=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(39=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(59=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(85=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(86=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(88=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(89=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(90=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(91=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(93=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(94=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(96=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(98=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(99=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(100=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(101=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(103=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(104=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(105=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(106=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(162=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(180=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(181=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(191=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(192=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(194=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(195=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(196=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(199=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(200=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(201=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(203=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(204=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(205=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(206=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(207=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(208=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(209=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(210=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(211=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(212=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(213=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(214=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(215=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(216=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(217=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(218=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(219=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(220=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(242=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(248=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(258=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(271=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(278=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(283=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(287=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(290=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(293=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(294=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(295=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(296=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(297=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(300=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(301=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(302=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(303=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(304=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(305=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(306=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(307=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(308=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(309=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(310=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(311=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(312=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(313=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(314=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(315=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(316=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(317=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(355=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(362=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(367=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(372=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(376=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(387=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(398=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(405=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(410=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(457=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(461=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(462=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(465=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(470=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(475=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(476=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(477=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(478=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(484=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(486=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(487=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(488=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(497=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(503=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(504=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(505=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(506=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(507=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(508=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(510=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(511=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(512=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(513=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(514=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(515=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(516=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(517=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(518=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(519=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(520=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(521=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(524=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(526=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(527=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(547=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(551=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(559=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(566=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(580=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(585=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(601=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(603=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_tuple(619=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_3(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_type_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_type_op_eol/7}). +yeccgoto_type_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(302, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(205, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(505, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_type_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(88, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_unary_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_unary_op_eol/7}). +yeccgoto_unary_op_eol(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(26, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(27, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(39, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(457, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(92, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(191, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(192, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(195, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(196, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(199, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(200, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(201, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(203, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(204, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(205, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(206, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(207, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(208, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(209, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(210, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(211, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(212, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(213, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(214, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(215, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(216, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(217, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(218, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(219, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(220, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(278, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(283, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(287, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(192, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(290, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(293, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(294, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(295, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(296, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(297, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(300, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(301, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(302, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(303, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(304, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(305, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(306, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(307, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(308, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(309, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(310, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(311, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(312, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(313, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(314, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(315, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(316, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(317, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(362, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(367, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(457, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(457, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(461, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(457, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(462, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_39(457, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(470, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(475, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(476, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(290, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(470, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(509, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(524, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(470, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(470, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_470(486, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unary_op_eol(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(2, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_unmatched_expr/7}). +-compile({nowarn_unused_function, yeccgoto_unmatched_expr/7}). +yeccgoto_unmatched_expr(0, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(2, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(6, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(7, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(8, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(9, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(20, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(23, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(32, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(37, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(59, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(85, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_447(447, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(86, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_445(445, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(88, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_443(443, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(89, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_441(441, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(90, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_439(439, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(91, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_437(437, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(92=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_435(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(93, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_433(433, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(94, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_431(431, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(96, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_429(429, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(98, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_427(427, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(99, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_425(425, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(100, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_423(423, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(101, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_421(421, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(103, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(104, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(105, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_152(152, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(106, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_146(146, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(162, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(180, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(181, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(194, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(242, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(248, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(258, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_261(261, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(271, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_261(261, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(355, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(372, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(376, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(387, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(398, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(405, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(410, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(465, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_469(469, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(470, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(477, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(478, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(484, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(486, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(487, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(488, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(497, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_469(498, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(503, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_447(447, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(504, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_445(445, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(505, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_443(443, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(506, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_441(441, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(507, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_439(439, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(508, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_437(437, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(509=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_435(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(510, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_433(433, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(511, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_431(431, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(512, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_429(429, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(513, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_427(427, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(514, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_425(425, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(515, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_423(423, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(516, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_421(421, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(517, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_159(159, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(518, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_156(156, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(519, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_529(529, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(520, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_152(152, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(521, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_146(146, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(524, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(526, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(527, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(547, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_548(548, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(551, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_469(498, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(559, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(566, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(580, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_581(581, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(585, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_581(581, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(601, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(603, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_1(1, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_expr(619, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_169(169, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_unmatched_op_expr/7}). +-compile({nowarn_unused_function, yeccgoto_unmatched_op_expr/7}). +yeccgoto_unmatched_op_expr(1=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(15=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(83=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(146=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(148=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(152=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(155=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(156=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(158=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(159=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(161=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(169=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(171=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(261=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(263=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(378=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(421=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(422=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(423=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(424=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(425=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(426=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(427=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(428=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(429=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(430=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(431=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(432=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(433=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(434=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(435=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(436=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(437=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(438=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(439=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(440=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(441=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(442=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(443=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(444=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(445=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(446=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(447=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(448=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(469=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(471=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(490=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(493=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(498=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(499=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(525=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(528=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(529=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(530=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(531=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(532=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(533=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(534=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(535=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(536=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(537=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(538=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(539=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(540=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(541=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(542=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(543=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(544=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(545=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(546=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(548=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(549=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(555=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(581=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_149(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(582=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_unmatched_op_expr(586=_S, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_87(_S, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_when_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_when_op_eol/7}). +yeccgoto_when_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_26(301, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(204, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(504, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_when_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_86(86, Cat, Ss, Stack, T, Ts, Tzr). + +-dialyzer({nowarn_function, yeccgoto_xor_op_eol/7}). +-compile({nowarn_unused_function, yeccgoto_xor_op_eol/7}). +yeccgoto_xor_op_eol(1, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(15, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(83, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(146, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(148, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(152, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(155, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(156, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(158, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(159, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(161, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(169, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(171, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(193, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(202, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(221, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(222, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(223, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(224, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(225, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(226, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(227, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(228, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(229, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(230, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(231, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(232, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(233, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(234, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(235, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(236, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(237, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(238, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(239, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(257, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(261, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(263, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(279, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(282, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(288, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(292, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(299, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(318, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(319, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(320, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(321, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(323, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(325, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(327, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(329, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(331, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(333, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(335, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(337, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(339, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(341, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(343, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(345, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(347, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(350, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(352, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(354, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(357, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(364, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(378, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(417, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_283(300, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(419, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(421, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(422, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(423, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(424, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(425, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(426, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(427, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(428, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(429, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(430, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(431, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(432, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(433, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(434, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(435, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(436, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(437, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(438, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(439, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(440, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(441, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(442, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(443, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(444, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(445, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(446, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(447, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(448, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(459, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_192(203, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(469, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(471, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(490, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(493, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(498, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(499, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(525, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(528, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(529, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(530, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(531, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(532, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(533, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(534, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(535, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(536, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(537, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(538, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(539, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(540, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(541, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(542, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(543, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(544, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(545, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(546, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(548, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(549, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(555, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(581, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(582, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_503(503, Cat, Ss, Stack, T, Ts, Tzr); +yeccgoto_xor_op_eol(586, Cat, Ss, Stack, T, Ts, Tzr) -> + yeccpars2_2(85, Cat, Ss, Stack, T, Ts, Tzr). + +-compile({inline,yeccpars2_0_/1}). +-dialyzer({nowarn_function, yeccpars2_0_/1}). +-compile({nowarn_unused_function, yeccpars2_0_/1}). +-file("src/future_elixir_parser.yrl", 93). +yeccpars2_0_(__Stack0) -> + [begin + {'__block__', [], []} + end | __Stack0]. + +-compile({inline,yeccpars2_1_/1}). +-dialyzer({nowarn_function, yeccpars2_1_/1}). +-compile({nowarn_unused_function, yeccpars2_1_/1}). +-file("src/future_elixir_parser.yrl", 101). +yeccpars2_1_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_3_/1}). +-dialyzer({nowarn_function, yeccpars2_3_/1}). +-compile({nowarn_unused_function, yeccpars2_3_/1}). +-file("src/future_elixir_parser.yrl", 273). +yeccpars2_3_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_4_/1}). +-dialyzer({nowarn_function, yeccpars2_4_/1}). +-compile({nowarn_unused_function, yeccpars2_4_/1}). +-file("src/future_elixir_parser.yrl", 148). +yeccpars2_4_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_5_/1}). +-dialyzer({nowarn_function, yeccpars2_5_/1}). +-compile({nowarn_unused_function, yeccpars2_5_/1}). +-file("src/future_elixir_parser.yrl", 288). +yeccpars2_5_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_10_/1}). +-dialyzer({nowarn_function, yeccpars2_10_/1}). +-compile({nowarn_unused_function, yeccpars2_10_/1}). +-file("src/future_elixir_parser.yrl", 250). +yeccpars2_10_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_11_/1}). +-dialyzer({nowarn_function, yeccpars2_11_/1}). +-compile({nowarn_unused_function, yeccpars2_11_/1}). +-file("src/future_elixir_parser.yrl", 147). +yeccpars2_11_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_12_/1}). +-dialyzer({nowarn_function, yeccpars2_12_/1}). +-compile({nowarn_unused_function, yeccpars2_12_/1}). +-file("src/future_elixir_parser.yrl", 165). +yeccpars2_12_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_13_/1}). +-dialyzer({nowarn_function, yeccpars2_13_/1}). +-compile({nowarn_unused_function, yeccpars2_13_/1}). +-file("src/future_elixir_parser.yrl", 166). +yeccpars2_13_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_14_/1}). +-dialyzer({nowarn_function, yeccpars2_14_/1}). +-compile({nowarn_unused_function, yeccpars2_14_/1}). +-file("src/future_elixir_parser.yrl", 100). +yeccpars2_14_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_15_/1}). +-dialyzer({nowarn_function, yeccpars2_15_/1}). +-compile({nowarn_unused_function, yeccpars2_15_/1}). +-file("src/future_elixir_parser.yrl", 99). +yeccpars2_15_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_17_/1}). +-dialyzer({nowarn_function, yeccpars2_17_/1}). +-compile({nowarn_unused_function, yeccpars2_17_/1}). +-file("src/future_elixir_parser.yrl", 272). +yeccpars2_17_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_18_/1}). +-dialyzer({nowarn_function, yeccpars2_18_/1}). +-compile({nowarn_unused_function, yeccpars2_18_/1}). +-file("src/future_elixir_parser.yrl", 271). +yeccpars2_18_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + element(1, ___1) + end | __Stack]. + +-compile({inline,yeccpars2_21_/1}). +-dialyzer({nowarn_function, yeccpars2_21_/1}). +-compile({nowarn_unused_function, yeccpars2_21_/1}). +-file("src/future_elixir_parser.yrl", 89). +yeccpars2_21_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_block(reverse(___1)) + end | __Stack]. + +-compile({inline,yeccpars2_22_/1}). +-dialyzer({nowarn_function, yeccpars2_22_/1}). +-compile({nowarn_unused_function, yeccpars2_22_/1}). +-file("src/future_elixir_parser.yrl", 96). +yeccpars2_22_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_23_/1}). +-dialyzer({nowarn_function, yeccpars2_23_/1}). +-compile({nowarn_unused_function, yeccpars2_23_/1}). +-file("src/future_elixir_parser.yrl", 88). +yeccpars2_23_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + {'__block__', meta_from_token(___1), []} + end | __Stack]. + +-compile({inline,yeccpars2_24_/1}). +-dialyzer({nowarn_function, yeccpars2_24_/1}). +-compile({nowarn_unused_function, yeccpars2_24_/1}). +-file("src/future_elixir_parser.yrl", 267). +yeccpars2_24_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + warn_empty_paren(___1), {'__block__', [], []} + end | __Stack]. + +-compile({inline,yeccpars2_25_/1}). +-dialyzer({nowarn_function, yeccpars2_25_/1}). +-compile({nowarn_unused_function, yeccpars2_25_/1}). +-file("src/future_elixir_parser.yrl", 484). +yeccpars2_25_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_27_/1}). +-dialyzer({nowarn_function, yeccpars2_27_/1}). +-compile({nowarn_unused_function, yeccpars2_27_/1}). +-file("src/future_elixir_parser.yrl", 248). +yeccpars2_27_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_identifier(___1) + end | __Stack]. + +-compile({inline,yeccpars2_28_/1}). +-dialyzer({nowarn_function, yeccpars2_28_/1}). +-compile({nowarn_unused_function, yeccpars2_28_/1}). +-file("src/future_elixir_parser.yrl", 247). +yeccpars2_28_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_identifier(___1) + end | __Stack]. + +-compile({inline,yeccpars2_31_/1}). +-dialyzer({nowarn_function, yeccpars2_31_/1}). +-compile({nowarn_unused_function, yeccpars2_31_/1}). +-file("src/future_elixir_parser.yrl", 287). +yeccpars2_31_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_33_/1}). +-dialyzer({nowarn_function, yeccpars2_33_/1}). +-compile({nowarn_unused_function, yeccpars2_33_/1}). +-file("src/future_elixir_parser.yrl", 261). +yeccpars2_33_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_34_/1}). +-dialyzer({nowarn_function, yeccpars2_34_/1}). +-compile({nowarn_unused_function, yeccpars2_34_/1}). +-file("src/future_elixir_parser.yrl", 260). +yeccpars2_34_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_35_/1}). +-dialyzer({nowarn_function, yeccpars2_35_/1}). +-compile({nowarn_unused_function, yeccpars2_35_/1}). +-file("src/future_elixir_parser.yrl", 158). +yeccpars2_35_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_36_/1}). +-dialyzer({nowarn_function, yeccpars2_36_/1}). +-compile({nowarn_unused_function, yeccpars2_36_/1}). +-file("src/future_elixir_parser.yrl", 281). +yeccpars2_36_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_38_/1}). +-dialyzer({nowarn_function, yeccpars2_38_/1}). +-compile({nowarn_unused_function, yeccpars2_38_/1}). +-file("src/future_elixir_parser.yrl", 253). +yeccpars2_38_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_40_/1}). +-dialyzer({nowarn_function, yeccpars2_40_/1}). +-compile({nowarn_unused_function, yeccpars2_40_/1}). +-file("src/future_elixir_parser.yrl", 628). +yeccpars2_40_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_41_/1}). +-dialyzer({nowarn_function, yeccpars2_41_/1}). +-compile({nowarn_unused_function, yeccpars2_41_/1}). +-file("src/future_elixir_parser.yrl", 365). +yeccpars2_41_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_42_/1}). +-dialyzer({nowarn_function, yeccpars2_42_/1}). +-compile({nowarn_unused_function, yeccpars2_42_/1}). +-file("src/future_elixir_parser.yrl", 319). +yeccpars2_42_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_43_/1}). +-dialyzer({nowarn_function, yeccpars2_43_/1}). +-compile({nowarn_unused_function, yeccpars2_43_/1}). +-file("src/future_elixir_parser.yrl", 377). +yeccpars2_43_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_44_/1}). +-dialyzer({nowarn_function, yeccpars2_44_/1}). +-compile({nowarn_unused_function, yeccpars2_44_/1}). +-file("src/future_elixir_parser.yrl", 372). +yeccpars2_44_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_45_/1}). +-dialyzer({nowarn_function, yeccpars2_45_/1}). +-compile({nowarn_unused_function, yeccpars2_45_/1}). +-file("src/future_elixir_parser.yrl", 467). +yeccpars2_45_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_alias(___1) + end | __Stack]. + +-compile({inline,yeccpars2_46_/1}). +-dialyzer({nowarn_function, yeccpars2_46_/1}). +-compile({nowarn_unused_function, yeccpars2_46_/1}). +-file("src/future_elixir_parser.yrl", 399). +yeccpars2_46_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27643). +-compile({inline,yeccpars2_47_/1}). +-dialyzer({nowarn_function, yeccpars2_47_/1}). +-compile({nowarn_unused_function, yeccpars2_47_/1}). +-file("src/future_elixir_parser.yrl", 283). +yeccpars2_47_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_literal(?exprs(___1), ___1) + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27654). +-compile({inline,yeccpars2_48_/1}). +-dialyzer({nowarn_function, yeccpars2_48_/1}). +-compile({nowarn_unused_function, yeccpars2_48_/1}). +-file("src/future_elixir_parser.yrl", 284). +yeccpars2_48_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_literal(?exprs(___1), ___1, delimiter(<<$">>)) + end | __Stack]. + +-compile({inline,yeccpars2_49_/1}). +-dialyzer({nowarn_function, yeccpars2_49_/1}). +-compile({nowarn_unused_function, yeccpars2_49_/1}). +-file("src/future_elixir_parser.yrl", 285). +yeccpars2_49_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_quoted_atom(___1, true, delimiter(<<$">>)) + end | __Stack]. + +-compile({inline,yeccpars2_50_/1}). +-dialyzer({nowarn_function, yeccpars2_50_/1}). +-compile({nowarn_unused_function, yeccpars2_50_/1}). +-file("src/future_elixir_parser.yrl", 286). +yeccpars2_50_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_quoted_atom(___1, false, delimiter(<<$">>)) + end | __Stack]. + +-compile({inline,yeccpars2_51_/1}). +-dialyzer({nowarn_function, yeccpars2_51_/1}). +-compile({nowarn_unused_function, yeccpars2_51_/1}). +-file("src/future_elixir_parser.yrl", 279). +yeccpars2_51_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_bin_heredoc(___1) + end | __Stack]. + +-compile({inline,yeccpars2_52_/1}). +-dialyzer({nowarn_function, yeccpars2_52_/1}). +-compile({nowarn_unused_function, yeccpars2_52_/1}). +-file("src/future_elixir_parser.yrl", 277). +yeccpars2_52_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_bin_string(___1, delimiter(<<$">>)) + end | __Stack]. + +-compile({inline,yeccpars2_53_/1}). +-dialyzer({nowarn_function, yeccpars2_53_/1}). +-compile({nowarn_unused_function, yeccpars2_53_/1}). +-file("src/future_elixir_parser.yrl", 478). +yeccpars2_53_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_55_/1}). +-dialyzer({nowarn_function, yeccpars2_55_/1}). +-compile({nowarn_unused_function, yeccpars2_55_/1}). +-file("src/future_elixir_parser.yrl", 396). +yeccpars2_55_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27725). +-compile({inline,yeccpars2_56_/1}). +-dialyzer({nowarn_function, yeccpars2_56_/1}). +-compile({nowarn_unused_function, yeccpars2_56_/1}). +-file("src/future_elixir_parser.yrl", 270). +yeccpars2_56_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_number(?exprs(___1), ___1, number_value(___1)) + end | __Stack]. + +-compile({inline,yeccpars2_57_/1}). +-dialyzer({nowarn_function, yeccpars2_57_/1}). +-compile({nowarn_unused_function, yeccpars2_57_/1}). +-file("src/future_elixir_parser.yrl", 475). +yeccpars2_57_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_58_/1}). +-dialyzer({nowarn_function, yeccpars2_58_/1}). +-compile({nowarn_unused_function, yeccpars2_58_/1}). +-file("src/future_elixir_parser.yrl", 391). +yeccpars2_58_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_59_/1}). +-dialyzer({nowarn_function, yeccpars2_59_/1}). +-compile({nowarn_unused_function, yeccpars2_59_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_59_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_60_/1}). +-dialyzer({nowarn_function, yeccpars2_60_/1}). +-compile({nowarn_unused_function, yeccpars2_60_/1}). +-file("src/future_elixir_parser.yrl", 318). +yeccpars2_60_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27776). +-compile({inline,yeccpars2_61_/1}). +-dialyzer({nowarn_function, yeccpars2_61_/1}). +-compile({nowarn_unused_function, yeccpars2_61_/1}). +-file("src/future_elixir_parser.yrl", 275). +yeccpars2_61_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_literal(?id(___1), ___1) + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27787). +-compile({inline,yeccpars2_62_/1}). +-dialyzer({nowarn_function, yeccpars2_62_/1}). +-compile({nowarn_unused_function, yeccpars2_62_/1}). +-file("src/future_elixir_parser.yrl", 269). +yeccpars2_62_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_number(number_value(___1), ___1, ?exprs(___1)) + end | __Stack]. + +-compile({inline,yeccpars2_63_/1}). +-dialyzer({nowarn_function, yeccpars2_63_/1}). +-compile({nowarn_unused_function, yeccpars2_63_/1}). +-file("src/future_elixir_parser.yrl", 322). +yeccpars2_63_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_64_/1}). +-dialyzer({nowarn_function, yeccpars2_64_/1}). +-compile({nowarn_unused_function, yeccpars2_64_/1}). +-file("src/future_elixir_parser.yrl", 464). +yeccpars2_64_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27818). +-compile({inline,yeccpars2_65_/1}). +-dialyzer({nowarn_function, yeccpars2_65_/1}). +-compile({nowarn_unused_function, yeccpars2_65_/1}). +-file("src/future_elixir_parser.yrl", 268). +yeccpars2_65_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_number(number_value(___1), ___1, ?exprs(___1)) + end | __Stack]. + +-compile({inline,yeccpars2_66_/1}). +-dialyzer({nowarn_function, yeccpars2_66_/1}). +-compile({nowarn_unused_function, yeccpars2_66_/1}). +-file("src/future_elixir_parser.yrl", 280). +yeccpars2_66_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_list_heredoc(___1) + end | __Stack]. + +-compile({inline,yeccpars2_67_/1}). +-dialyzer({nowarn_function, yeccpars2_67_/1}). +-compile({nowarn_unused_function, yeccpars2_67_/1}). +-file("src/future_elixir_parser.yrl", 278). +yeccpars2_67_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_list_string(___1, delimiter(<<$'>>)) + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27849). +-compile({inline,yeccpars2_68_/1}). +-dialyzer({nowarn_function, yeccpars2_68_/1}). +-compile({nowarn_unused_function, yeccpars2_68_/1}). +-file("src/future_elixir_parser.yrl", 276). +yeccpars2_68_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_literal(?id(___1), ___1) + end | __Stack]. + +-compile({inline,yeccpars2_69_/1}). +-dialyzer({nowarn_function, yeccpars2_69_/1}). +-compile({nowarn_unused_function, yeccpars2_69_/1}). +-file("src/future_elixir_parser.yrl", 472). +yeccpars2_69_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_70_/1}). +-dialyzer({nowarn_function, yeccpars2_70_/1}). +-compile({nowarn_unused_function, yeccpars2_70_/1}). +-file("src/future_elixir_parser.yrl", 481). +yeccpars2_70_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_71_/1}). +-dialyzer({nowarn_function, yeccpars2_71_/1}). +-compile({nowarn_unused_function, yeccpars2_71_/1}). +-file("src/future_elixir_parser.yrl", 251). +yeccpars2_71_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_72_/1}). +-dialyzer({nowarn_function, yeccpars2_72_/1}). +-compile({nowarn_unused_function, yeccpars2_72_/1}). +-file("src/future_elixir_parser.yrl", 282). +yeccpars2_72_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_sigil(___1) + end | __Stack]. + +-compile({inline,yeccpars2_73_/1}). +-dialyzer({nowarn_function, yeccpars2_73_/1}). +-compile({nowarn_unused_function, yeccpars2_73_/1}). +-file("src/future_elixir_parser.yrl", 393). +yeccpars2_73_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-file("src/future_elixir_parser.erl", 27910). +-compile({inline,yeccpars2_74_/1}). +-dialyzer({nowarn_function, yeccpars2_74_/1}). +-compile({nowarn_unused_function, yeccpars2_74_/1}). +-file("src/future_elixir_parser.yrl", 274). +yeccpars2_74_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_literal(?id(___1), ___1) + end | __Stack]. + +-compile({inline,yeccpars2_75_/1}). +-dialyzer({nowarn_function, yeccpars2_75_/1}). +-compile({nowarn_unused_function, yeccpars2_75_/1}). +-file("src/future_elixir_parser.yrl", 389). +yeccpars2_75_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_76_/1}). +-dialyzer({nowarn_function, yeccpars2_76_/1}). +-compile({nowarn_unused_function, yeccpars2_76_/1}). +-file("src/future_elixir_parser.yrl", 382). +yeccpars2_76_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_77_/1}). +-dialyzer({nowarn_function, yeccpars2_77_/1}). +-compile({nowarn_unused_function, yeccpars2_77_/1}). +-file("src/future_elixir_parser.yrl", 383). +yeccpars2_77_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_78_/1}). +-dialyzer({nowarn_function, yeccpars2_78_/1}). +-compile({nowarn_unused_function, yeccpars2_78_/1}). +-file("src/future_elixir_parser.yrl", 390). +yeccpars2_78_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_79_/1}). +-dialyzer({nowarn_function, yeccpars2_79_/1}). +-compile({nowarn_unused_function, yeccpars2_79_/1}). +-file("src/future_elixir_parser.yrl", 394). +yeccpars2_79_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_80_/1}). +-dialyzer({nowarn_function, yeccpars2_80_/1}). +-compile({nowarn_unused_function, yeccpars2_80_/1}). +-file("src/future_elixir_parser.yrl", 323). +yeccpars2_80_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_81_/1}). +-dialyzer({nowarn_function, yeccpars2_81_/1}). +-compile({nowarn_unused_function, yeccpars2_81_/1}). +-file("src/future_elixir_parser.yrl", 320). +yeccpars2_81_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_82_/1}). +-dialyzer({nowarn_function, yeccpars2_82_/1}). +-compile({nowarn_unused_function, yeccpars2_82_/1}). +-file("src/future_elixir_parser.yrl", 164). +yeccpars2_82_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_83_/1}). +-dialyzer({nowarn_function, yeccpars2_83_/1}). +-compile({nowarn_unused_function, yeccpars2_83_/1}). +-file("src/future_elixir_parser.yrl", 146). +yeccpars2_83_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_84_/1}). +-dialyzer({nowarn_function, yeccpars2_84_/1}). +-compile({nowarn_unused_function, yeccpars2_84_/1}). +-file("src/future_elixir_parser.yrl", 157). +yeccpars2_84_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_87_/1}). +-dialyzer({nowarn_function, yeccpars2_87_/1}). +-compile({nowarn_unused_function, yeccpars2_87_/1}). +-file("src/future_elixir_parser.yrl", 150). +yeccpars2_87_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_95_/1}). +-dialyzer({nowarn_function, yeccpars2_95_/1}). +-compile({nowarn_unused_function, yeccpars2_95_/1}). +-file("src/future_elixir_parser.yrl", 160). +yeccpars2_95_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_97_/1}). +-dialyzer({nowarn_function, yeccpars2_97_/1}). +-compile({nowarn_unused_function, yeccpars2_97_/1}). +-file("src/future_elixir_parser.yrl", 142). +yeccpars2_97_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_107_/1}). +-dialyzer({nowarn_function, yeccpars2_107_/1}). +-compile({nowarn_unused_function, yeccpars2_107_/1}). +-file("src/future_elixir_parser.yrl", 461). +yeccpars2_107_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_108_/1}). +-dialyzer({nowarn_function, yeccpars2_108_/1}). +-compile({nowarn_unused_function, yeccpars2_108_/1}). +-file("src/future_elixir_parser.yrl", 429). +yeccpars2_108_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_109_/1}). +-dialyzer({nowarn_function, yeccpars2_109_/1}). +-compile({nowarn_unused_function, yeccpars2_109_/1}). +-file("src/future_elixir_parser.yrl", 456). +yeccpars2_109_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_110_/1}). +-dialyzer({nowarn_function, yeccpars2_110_/1}). +-compile({nowarn_unused_function, yeccpars2_110_/1}). +-file("src/future_elixir_parser.yrl", 450). +yeccpars2_110_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_111_/1}). +-dialyzer({nowarn_function, yeccpars2_111_/1}). +-compile({nowarn_unused_function, yeccpars2_111_/1}). +-file("src/future_elixir_parser.yrl", 414). +yeccpars2_111_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_112_/1}). +-dialyzer({nowarn_function, yeccpars2_112_/1}). +-compile({nowarn_unused_function, yeccpars2_112_/1}). +-file("src/future_elixir_parser.yrl", 485). +yeccpars2_112_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {'.', meta_from_token(___2), [___1]} + end | __Stack]. + +-compile({inline,yeccpars2_113_/1}). +-dialyzer({nowarn_function, yeccpars2_113_/1}). +-compile({nowarn_unused_function, yeccpars2_113_/1}). +-file("src/future_elixir_parser.yrl", 405). +yeccpars2_113_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_114_/1}). +-dialyzer({nowarn_function, yeccpars2_114_/1}). +-compile({nowarn_unused_function, yeccpars2_114_/1}). +-file("src/future_elixir_parser.yrl", 438). +yeccpars2_114_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_115_/1}). +-dialyzer({nowarn_function, yeccpars2_115_/1}). +-compile({nowarn_unused_function, yeccpars2_115_/1}). +-file("src/future_elixir_parser.yrl", 435). +yeccpars2_115_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_116_/1}). +-dialyzer({nowarn_function, yeccpars2_116_/1}). +-compile({nowarn_unused_function, yeccpars2_116_/1}). +-file("src/future_elixir_parser.yrl", 402). +yeccpars2_116_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_117_/1}). +-dialyzer({nowarn_function, yeccpars2_117_/1}). +-compile({nowarn_unused_function, yeccpars2_117_/1}). +-file("src/future_elixir_parser.yrl", 408). +yeccpars2_117_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_118_/1}). +-dialyzer({nowarn_function, yeccpars2_118_/1}). +-compile({nowarn_unused_function, yeccpars2_118_/1}). +-file("src/future_elixir_parser.yrl", 432). +yeccpars2_118_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_119_/1}). +-dialyzer({nowarn_function, yeccpars2_119_/1}). +-compile({nowarn_unused_function, yeccpars2_119_/1}). +-file("src/future_elixir_parser.yrl", 426). +yeccpars2_119_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_120_/1}). +-dialyzer({nowarn_function, yeccpars2_120_/1}). +-compile({nowarn_unused_function, yeccpars2_120_/1}). +-file("src/future_elixir_parser.yrl", 411). +yeccpars2_120_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_121_/1}). +-dialyzer({nowarn_function, yeccpars2_121_/1}). +-compile({nowarn_unused_function, yeccpars2_121_/1}). +-file("src/future_elixir_parser.yrl", 417). +yeccpars2_121_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_122_/1}). +-dialyzer({nowarn_function, yeccpars2_122_/1}). +-compile({nowarn_unused_function, yeccpars2_122_/1}). +-file("src/future_elixir_parser.yrl", 453). +yeccpars2_122_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_123_/1}). +-dialyzer({nowarn_function, yeccpars2_123_/1}). +-compile({nowarn_unused_function, yeccpars2_123_/1}). +-file("src/future_elixir_parser.yrl", 420). +yeccpars2_123_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_124_/1}). +-dialyzer({nowarn_function, yeccpars2_124_/1}). +-compile({nowarn_unused_function, yeccpars2_124_/1}). +-file("src/future_elixir_parser.yrl", 441). +yeccpars2_124_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_125_/1}). +-dialyzer({nowarn_function, yeccpars2_125_/1}). +-compile({nowarn_unused_function, yeccpars2_125_/1}). +-file("src/future_elixir_parser.yrl", 444). +yeccpars2_125_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_126_/1}). +-dialyzer({nowarn_function, yeccpars2_126_/1}). +-compile({nowarn_unused_function, yeccpars2_126_/1}). +-file("src/future_elixir_parser.yrl", 423). +yeccpars2_126_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_127_/1}). +-dialyzer({nowarn_function, yeccpars2_127_/1}). +-compile({nowarn_unused_function, yeccpars2_127_/1}). +-file("src/future_elixir_parser.yrl", 424). +yeccpars2_127_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_128_/1}). +-dialyzer({nowarn_function, yeccpars2_128_/1}). +-compile({nowarn_unused_function, yeccpars2_128_/1}). +-file("src/future_elixir_parser.yrl", 445). +yeccpars2_128_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_129_/1}). +-dialyzer({nowarn_function, yeccpars2_129_/1}). +-compile({nowarn_unused_function, yeccpars2_129_/1}). +-file("src/future_elixir_parser.yrl", 442). +yeccpars2_129_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_130_/1}). +-dialyzer({nowarn_function, yeccpars2_130_/1}). +-compile({nowarn_unused_function, yeccpars2_130_/1}). +-file("src/future_elixir_parser.yrl", 421). +yeccpars2_130_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_131_/1}). +-dialyzer({nowarn_function, yeccpars2_131_/1}). +-compile({nowarn_unused_function, yeccpars2_131_/1}). +-file("src/future_elixir_parser.yrl", 454). +yeccpars2_131_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_132_/1}). +-dialyzer({nowarn_function, yeccpars2_132_/1}). +-compile({nowarn_unused_function, yeccpars2_132_/1}). +-file("src/future_elixir_parser.yrl", 418). +yeccpars2_132_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_133_/1}). +-dialyzer({nowarn_function, yeccpars2_133_/1}). +-compile({nowarn_unused_function, yeccpars2_133_/1}). +-file("src/future_elixir_parser.yrl", 412). +yeccpars2_133_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_134_/1}). +-dialyzer({nowarn_function, yeccpars2_134_/1}). +-compile({nowarn_unused_function, yeccpars2_134_/1}). +-file("src/future_elixir_parser.yrl", 427). +yeccpars2_134_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_135_/1}). +-dialyzer({nowarn_function, yeccpars2_135_/1}). +-compile({nowarn_unused_function, yeccpars2_135_/1}). +-file("src/future_elixir_parser.yrl", 433). +yeccpars2_135_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_136_/1}). +-dialyzer({nowarn_function, yeccpars2_136_/1}). +-compile({nowarn_unused_function, yeccpars2_136_/1}). +-file("src/future_elixir_parser.yrl", 409). +yeccpars2_136_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_137_/1}). +-dialyzer({nowarn_function, yeccpars2_137_/1}). +-compile({nowarn_unused_function, yeccpars2_137_/1}). +-file("src/future_elixir_parser.yrl", 403). +yeccpars2_137_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_138_/1}). +-dialyzer({nowarn_function, yeccpars2_138_/1}). +-compile({nowarn_unused_function, yeccpars2_138_/1}). +-file("src/future_elixir_parser.yrl", 436). +yeccpars2_138_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_139_/1}). +-dialyzer({nowarn_function, yeccpars2_139_/1}). +-compile({nowarn_unused_function, yeccpars2_139_/1}). +-file("src/future_elixir_parser.yrl", 439). +yeccpars2_139_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_140_/1}). +-dialyzer({nowarn_function, yeccpars2_140_/1}). +-compile({nowarn_unused_function, yeccpars2_140_/1}). +-file("src/future_elixir_parser.yrl", 406). +yeccpars2_140_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_141_/1}). +-dialyzer({nowarn_function, yeccpars2_141_/1}). +-compile({nowarn_unused_function, yeccpars2_141_/1}). +-file("src/future_elixir_parser.yrl", 415). +yeccpars2_141_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_142_/1}). +-dialyzer({nowarn_function, yeccpars2_142_/1}). +-compile({nowarn_unused_function, yeccpars2_142_/1}). +-file("src/future_elixir_parser.yrl", 451). +yeccpars2_142_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_143_/1}). +-dialyzer({nowarn_function, yeccpars2_143_/1}). +-compile({nowarn_unused_function, yeccpars2_143_/1}). +-file("src/future_elixir_parser.yrl", 457). +yeccpars2_143_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_144_/1}). +-dialyzer({nowarn_function, yeccpars2_144_/1}). +-compile({nowarn_unused_function, yeccpars2_144_/1}). +-file("src/future_elixir_parser.yrl", 430). +yeccpars2_144_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_145_/1}). +-dialyzer({nowarn_function, yeccpars2_145_/1}). +-compile({nowarn_unused_function, yeccpars2_145_/1}). +-file("src/future_elixir_parser.yrl", 462). +yeccpars2_145_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_146_/1}). +-dialyzer({nowarn_function, yeccpars2_146_/1}). +-compile({nowarn_unused_function, yeccpars2_146_/1}). +-file("src/future_elixir_parser.yrl", 206). +yeccpars2_146_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_147_/1}). +-dialyzer({nowarn_function, yeccpars2_147_/1}). +-compile({nowarn_unused_function, yeccpars2_147_/1}). +-file("src/future_elixir_parser.yrl", 225). +yeccpars2_147_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_148_/1}). +-dialyzer({nowarn_function, yeccpars2_148_/1}). +-compile({nowarn_unused_function, yeccpars2_148_/1}). +-file("src/future_elixir_parser.yrl", 182). +yeccpars2_148_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_149_/1}). +-dialyzer({nowarn_function, yeccpars2_149_/1}). +-compile({nowarn_unused_function, yeccpars2_149_/1}). +-file("src/future_elixir_parser.yrl", 152). +yeccpars2_149_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_150_/1}). +-dialyzer({nowarn_function, yeccpars2_150_/1}). +-compile({nowarn_unused_function, yeccpars2_150_/1}). +-file("src/future_elixir_parser.yrl", 153). +yeccpars2_150_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + warn_no_parens_after_do_op(___2), build_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_151_/1}). +-dialyzer({nowarn_function, yeccpars2_151_/1}). +-compile({nowarn_unused_function, yeccpars2_151_/1}). +-file("src/future_elixir_parser.yrl", 151). +yeccpars2_151_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_152_/1}). +-dialyzer({nowarn_function, yeccpars2_152_/1}). +-compile({nowarn_unused_function, yeccpars2_152_/1}). +-file("src/future_elixir_parser.yrl", 215). +yeccpars2_152_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_153_/1}). +-dialyzer({nowarn_function, yeccpars2_153_/1}). +-compile({nowarn_unused_function, yeccpars2_153_/1}). +-file("src/future_elixir_parser.yrl", 196). +yeccpars2_153_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + warn_pipe(___1, ___2), {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_154_/1}). +-dialyzer({nowarn_function, yeccpars2_154_/1}). +-compile({nowarn_unused_function, yeccpars2_154_/1}). +-file("src/future_elixir_parser.yrl", 234). +yeccpars2_154_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + warn_pipe(___1, ___2), {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_155_/1}). +-dialyzer({nowarn_function, yeccpars2_155_/1}). +-compile({nowarn_unused_function, yeccpars2_155_/1}). +-file("src/future_elixir_parser.yrl", 191). +yeccpars2_155_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_156_/1}). +-dialyzer({nowarn_function, yeccpars2_156_/1}). +-compile({nowarn_unused_function, yeccpars2_156_/1}). +-file("src/future_elixir_parser.yrl", 213). +yeccpars2_156_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_157_/1}). +-dialyzer({nowarn_function, yeccpars2_157_/1}). +-compile({nowarn_unused_function, yeccpars2_157_/1}). +-file("src/future_elixir_parser.yrl", 232). +yeccpars2_157_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_158_/1}). +-dialyzer({nowarn_function, yeccpars2_158_/1}). +-compile({nowarn_unused_function, yeccpars2_158_/1}). +-file("src/future_elixir_parser.yrl", 189). +yeccpars2_158_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_159_/1}). +-dialyzer({nowarn_function, yeccpars2_159_/1}). +-compile({nowarn_unused_function, yeccpars2_159_/1}). +-file("src/future_elixir_parser.yrl", 202). +yeccpars2_159_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_160_/1}). +-dialyzer({nowarn_function, yeccpars2_160_/1}). +-compile({nowarn_unused_function, yeccpars2_160_/1}). +-file("src/future_elixir_parser.yrl", 221). +yeccpars2_160_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_161_/1}). +-dialyzer({nowarn_function, yeccpars2_161_/1}). +-compile({nowarn_unused_function, yeccpars2_161_/1}). +-file("src/future_elixir_parser.yrl", 178). +yeccpars2_161_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_163_/1}). +-dialyzer({nowarn_function, yeccpars2_163_/1}). +-compile({nowarn_unused_function, yeccpars2_163_/1}). +-file("src/future_elixir_parser.yrl", 468). +yeccpars2_163_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot_alias(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_164_/1}). +-dialyzer({nowarn_function, yeccpars2_164_/1}). +-compile({nowarn_unused_function, yeccpars2_164_/1}). +-file("src/future_elixir_parser.yrl", 479). +yeccpars2_164_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_165_/1}). +-dialyzer({nowarn_function, yeccpars2_165_/1}). +-compile({nowarn_unused_function, yeccpars2_165_/1}). +-file("src/future_elixir_parser.yrl", 476). +yeccpars2_165_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_166_/1}). +-dialyzer({nowarn_function, yeccpars2_166_/1}). +-compile({nowarn_unused_function, yeccpars2_166_/1}). +-file("src/future_elixir_parser.yrl", 465). +yeccpars2_166_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_167_/1}). +-dialyzer({nowarn_function, yeccpars2_167_/1}). +-compile({nowarn_unused_function, yeccpars2_167_/1}). +-file("src/future_elixir_parser.yrl", 473). +yeccpars2_167_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_168_/1}). +-dialyzer({nowarn_function, yeccpars2_168_/1}). +-compile({nowarn_unused_function, yeccpars2_168_/1}). +-file("src/future_elixir_parser.yrl", 482). +yeccpars2_168_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_169_/1}). +-dialyzer({nowarn_function, yeccpars2_169_/1}). +-compile({nowarn_unused_function, yeccpars2_169_/1}). +-file("src/future_elixir_parser.yrl", 521). +yeccpars2_169_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_170_/1}). +-dialyzer({nowarn_function, yeccpars2_170_/1}). +-compile({nowarn_unused_function, yeccpars2_170_/1}). +-file("src/future_elixir_parser.yrl", 522). +yeccpars2_170_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + error_no_parens_container_strict(___1) + end | __Stack]. + +-compile({inline,yeccpars2_171_/1}). +-dialyzer({nowarn_function, yeccpars2_171_/1}). +-compile({nowarn_unused_function, yeccpars2_171_/1}). +-file("src/future_elixir_parser.yrl", 520). +yeccpars2_171_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_172_/1}). +-dialyzer({nowarn_function, yeccpars2_172_/1}). +-compile({nowarn_unused_function, yeccpars2_172_/1}). +-file("src/future_elixir_parser.yrl", 524). +yeccpars2_172_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_173_/1}). +-dialyzer({nowarn_function, yeccpars2_173_/1}). +-compile({nowarn_unused_function, yeccpars2_173_/1}). +-file("src/future_elixir_parser.yrl", 527). +yeccpars2_173_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_175_/1}). +-dialyzer({nowarn_function, yeccpars2_175_/1}). +-compile({nowarn_unused_function, yeccpars2_175_/1}). +-file("src/future_elixir_parser.yrl", 469). +yeccpars2_175_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot_container(___2, ___1, [], []) + end | __Stack]. + +-compile({inline,yeccpars2_176_/1}). +-dialyzer({nowarn_function, yeccpars2_176_/1}). +-compile({nowarn_unused_function, yeccpars2_176_/1}). +-file("src/future_elixir_parser.yrl", 470). +yeccpars2_176_(__Stack0) -> + [___5,___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_dot_container(___2, ___1, ___4, newlines_pair(___3, ___5)) + end | __Stack]. + +-compile({inline,yeccpars2_178_/1}). +-dialyzer({nowarn_function, yeccpars2_178_/1}). +-compile({nowarn_unused_function, yeccpars2_178_/1}). +-file("src/future_elixir_parser.yrl", 384). +yeccpars2_178_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_179_/1}). +-dialyzer({nowarn_function, yeccpars2_179_/1}). +-compile({nowarn_unused_function, yeccpars2_179_/1}). +-file("src/future_elixir_parser.yrl", 385). +yeccpars2_179_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___2 + end | __Stack]. + +-compile({inline,yeccpars2_180_/1}). +-dialyzer({nowarn_function, yeccpars2_180_/1}). +-compile({nowarn_unused_function, yeccpars2_180_/1}). +-file("src/future_elixir_parser.yrl", 528). +yeccpars2_180_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_182_/1}). +-dialyzer({nowarn_function, yeccpars2_182_/1}). +-compile({nowarn_unused_function, yeccpars2_182_/1}). +-file("src/future_elixir_parser.yrl", 529). +yeccpars2_182_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + reverse([___3 | ___1]) + end | __Stack]. + +-compile({inline,yeccpars2_183_/1}). +-dialyzer({nowarn_function, yeccpars2_183_/1}). +-compile({nowarn_unused_function, yeccpars2_183_/1}). +-file("src/future_elixir_parser.yrl", 567). +yeccpars2_183_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_184_/1}). +-dialyzer({nowarn_function, yeccpars2_184_/1}). +-compile({nowarn_unused_function, yeccpars2_184_/1}). +-file("src/future_elixir_parser.yrl", 525). +yeccpars2_184_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3 | ___1] + end | __Stack]. + +-file("src/future_elixir_parser.erl", 28791). +-compile({inline,yeccpars2_185_/1}). +-dialyzer({nowarn_function, yeccpars2_185_/1}). +-compile({nowarn_unused_function, yeccpars2_185_/1}). +-file("src/future_elixir_parser.yrl", 553). +yeccpars2_185_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + handle_literal(?exprs(___1), ___1, [{format, keyword}]) + end | __Stack]. + +-compile({inline,yeccpars2_186_/1}). +-dialyzer({nowarn_function, yeccpars2_186_/1}). +-compile({nowarn_unused_function, yeccpars2_186_/1}). +-file("src/future_elixir_parser.yrl", 555). +yeccpars2_186_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_quoted_atom(___1, true, [{format, keyword}]) + end | __Stack]. + +-compile({inline,yeccpars2_187_/1}). +-dialyzer({nowarn_function, yeccpars2_187_/1}). +-compile({nowarn_unused_function, yeccpars2_187_/1}). +-file("src/future_elixir_parser.yrl", 557). +yeccpars2_187_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_quoted_atom(___1, false, [{format, keyword}]) + end | __Stack]. + +-compile({inline,yeccpars2_188_/1}). +-dialyzer({nowarn_function, yeccpars2_188_/1}). +-compile({nowarn_unused_function, yeccpars2_188_/1}). +-file("src/future_elixir_parser.yrl", 558). +yeccpars2_188_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_quoted_atom(___1, false, [{format, keyword}]) + end | __Stack]. + +-compile({inline,yeccpars2_189_/1}). +-dialyzer({nowarn_function, yeccpars2_189_/1}). +-compile({nowarn_unused_function, yeccpars2_189_/1}). +-file("src/future_elixir_parser.yrl", 556). +yeccpars2_189_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_quoted_atom(___1, true, [{format, keyword}]) + end | __Stack]. + +-file("src/future_elixir_parser.erl", 28842). +-compile({inline,yeccpars2_190_/1}). +-dialyzer({nowarn_function, yeccpars2_190_/1}). +-compile({nowarn_unused_function, yeccpars2_190_/1}). +-file("src/future_elixir_parser.yrl", 554). +yeccpars2_190_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + handle_literal(?exprs(___1), ___1, [{format, keyword}]) + end | __Stack]. + +-compile({inline,yeccpars2_191_/1}). +-dialyzer({nowarn_function, yeccpars2_191_/1}). +-compile({nowarn_unused_function, yeccpars2_191_/1}). +-file("src/future_elixir_parser.yrl", 568). +yeccpars2_191_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_193_/1}). +-dialyzer({nowarn_function, yeccpars2_193_/1}). +-compile({nowarn_unused_function, yeccpars2_193_/1}). +-file("src/future_elixir_parser.yrl", 569). +yeccpars2_193_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + maybe_bad_keyword_data_follow_up(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_196_/1}). +-dialyzer({nowarn_function, yeccpars2_196_/1}). +-compile({nowarn_unused_function, yeccpars2_196_/1}). +-file("src/future_elixir_parser.yrl", 248). +yeccpars2_196_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_identifier(___1) + end | __Stack]. + +-compile({inline,yeccpars2_197_/1}). +-dialyzer({nowarn_function, yeccpars2_197_/1}). +-compile({nowarn_unused_function, yeccpars2_197_/1}). +-file("src/future_elixir_parser.yrl", 247). +yeccpars2_197_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_identifier(___1) + end | __Stack]. + +-compile({inline,yeccpars2_201_/1}). +-dialyzer({nowarn_function, yeccpars2_201_/1}). +-compile({nowarn_unused_function, yeccpars2_201_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_201_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_202_/1}). +-dialyzer({nowarn_function, yeccpars2_202_/1}). +-compile({nowarn_unused_function, yeccpars2_202_/1}). +-file("src/future_elixir_parser.yrl", 146). +yeccpars2_202_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_221_/1}). +-dialyzer({nowarn_function, yeccpars2_221_/1}). +-compile({nowarn_unused_function, yeccpars2_221_/1}). +-file("src/future_elixir_parser.yrl", 182). +yeccpars2_221_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_222_/1}). +-dialyzer({nowarn_function, yeccpars2_222_/1}). +-compile({nowarn_unused_function, yeccpars2_222_/1}). +-file("src/future_elixir_parser.yrl", 191). +yeccpars2_222_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_223_/1}). +-dialyzer({nowarn_function, yeccpars2_223_/1}). +-compile({nowarn_unused_function, yeccpars2_223_/1}). +-file("src/future_elixir_parser.yrl", 189). +yeccpars2_223_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_224_/1}). +-dialyzer({nowarn_function, yeccpars2_224_/1}). +-compile({nowarn_unused_function, yeccpars2_224_/1}). +-file("src/future_elixir_parser.yrl", 178). +yeccpars2_224_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_225_/1}). +-dialyzer({nowarn_function, yeccpars2_225_/1}). +-compile({nowarn_unused_function, yeccpars2_225_/1}). +-file("src/future_elixir_parser.yrl", 175). +yeccpars2_225_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_226_/1}). +-dialyzer({nowarn_function, yeccpars2_226_/1}). +-compile({nowarn_unused_function, yeccpars2_226_/1}). +-file("src/future_elixir_parser.yrl", 185). +yeccpars2_226_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_227_/1}). +-dialyzer({nowarn_function, yeccpars2_227_/1}). +-compile({nowarn_unused_function, yeccpars2_227_/1}). +-file("src/future_elixir_parser.yrl", 184). +yeccpars2_227_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_228_/1}). +-dialyzer({nowarn_function, yeccpars2_228_/1}). +-compile({nowarn_unused_function, yeccpars2_228_/1}). +-file("src/future_elixir_parser.yrl", 174). +yeccpars2_228_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_229_/1}). +-dialyzer({nowarn_function, yeccpars2_229_/1}). +-compile({nowarn_unused_function, yeccpars2_229_/1}). +-file("src/future_elixir_parser.yrl", 176). +yeccpars2_229_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_230_/1}). +-dialyzer({nowarn_function, yeccpars2_230_/1}). +-compile({nowarn_unused_function, yeccpars2_230_/1}). +-file("src/future_elixir_parser.yrl", 183). +yeccpars2_230_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_231_/1}). +-dialyzer({nowarn_function, yeccpars2_231_/1}). +-compile({nowarn_unused_function, yeccpars2_231_/1}). +-file("src/future_elixir_parser.yrl", 188). +yeccpars2_231_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_232_/1}). +-dialyzer({nowarn_function, yeccpars2_232_/1}). +-compile({nowarn_unused_function, yeccpars2_232_/1}). +-file("src/future_elixir_parser.yrl", 177). +yeccpars2_232_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_233_/1}). +-dialyzer({nowarn_function, yeccpars2_233_/1}). +-compile({nowarn_unused_function, yeccpars2_233_/1}). +-file("src/future_elixir_parser.yrl", 179). +yeccpars2_233_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_234_/1}). +-dialyzer({nowarn_function, yeccpars2_234_/1}). +-compile({nowarn_unused_function, yeccpars2_234_/1}). +-file("src/future_elixir_parser.yrl", 190). +yeccpars2_234_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_235_/1}). +-dialyzer({nowarn_function, yeccpars2_235_/1}). +-compile({nowarn_unused_function, yeccpars2_235_/1}). +-file("src/future_elixir_parser.yrl", 180). +yeccpars2_235_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_236_/1}). +-dialyzer({nowarn_function, yeccpars2_236_/1}). +-compile({nowarn_unused_function, yeccpars2_236_/1}). +-file("src/future_elixir_parser.yrl", 186). +yeccpars2_236_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_237_/1}). +-dialyzer({nowarn_function, yeccpars2_237_/1}). +-compile({nowarn_unused_function, yeccpars2_237_/1}). +-file("src/future_elixir_parser.yrl", 187). +yeccpars2_237_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_238_/1}). +-dialyzer({nowarn_function, yeccpars2_238_/1}). +-compile({nowarn_unused_function, yeccpars2_238_/1}). +-file("src/future_elixir_parser.yrl", 181). +yeccpars2_238_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_239_/1}). +-dialyzer({nowarn_function, yeccpars2_239_/1}). +-compile({nowarn_unused_function, yeccpars2_239_/1}). +-file("src/future_elixir_parser.yrl", 144). +yeccpars2_239_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_241_/1}). +-dialyzer({nowarn_function, yeccpars2_241_/1}). +-compile({nowarn_unused_function, yeccpars2_241_/1}). +-file("src/future_elixir_parser.yrl", 253). +yeccpars2_241_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_243_/1}). +-dialyzer({nowarn_function, yeccpars2_243_/1}). +-compile({nowarn_unused_function, yeccpars2_243_/1}). +-file("src/future_elixir_parser.yrl", 304). +yeccpars2_243_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + build_access(build_unary_op(___1, ___2), meta_with_from_brackets(___3)) + end | __Stack]. + +-compile({inline,yeccpars2_244_/1}). +-dialyzer({nowarn_function, yeccpars2_244_/1}). +-compile({nowarn_unused_function, yeccpars2_244_/1}). +-file("src/future_elixir_parser.yrl", 254). +yeccpars2_244_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + error_invalid_kw_identifier(___2) + end | __Stack]. + +-compile({inline,yeccpars2_247_/1}). +-dialyzer({nowarn_function, yeccpars2_247_/1}). +-compile({nowarn_unused_function, yeccpars2_247_/1}). +-file("src/future_elixir_parser.yrl", 295). +yeccpars2_247_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_access_arg(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_249_/1}). +-dialyzer({nowarn_function, yeccpars2_249_/1}). +-compile({nowarn_unused_function, yeccpars2_249_/1}). +-file("src/future_elixir_parser.yrl", 374). +yeccpars2_249_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_251_/1}). +-dialyzer({nowarn_function, yeccpars2_251_/1}). +-compile({nowarn_unused_function, yeccpars2_251_/1}). +-file("src/future_elixir_parser.yrl", 375). +yeccpars2_251_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___2 + end | __Stack]. + +-compile({inline,yeccpars2_253_/1}). +-dialyzer({nowarn_function, yeccpars2_253_/1}). +-compile({nowarn_unused_function, yeccpars2_253_/1}). +-file("src/future_elixir_parser.yrl", 296). +yeccpars2_253_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_access_arg(___1, ___2, ___4) + end | __Stack]. + +-compile({inline,yeccpars2_254_/1}). +-dialyzer({nowarn_function, yeccpars2_254_/1}). +-compile({nowarn_unused_function, yeccpars2_254_/1}). +-file("src/future_elixir_parser.yrl", 297). +yeccpars2_254_(__Stack0) -> + [___5,___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + error_too_many_access_syntax(___3) + end | __Stack]. + +-compile({inline,yeccpars2_255_/1}). +-dialyzer({nowarn_function, yeccpars2_255_/1}). +-compile({nowarn_unused_function, yeccpars2_255_/1}). +-file("src/future_elixir_parser.yrl", 294). +yeccpars2_255_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_access_arg(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_256_/1}). +-dialyzer({nowarn_function, yeccpars2_256_/1}). +-compile({nowarn_unused_function, yeccpars2_256_/1}). +-file("src/future_elixir_parser.yrl", 302). +yeccpars2_256_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + build_access(build_unary_op(___1, build_identifier(___2)), meta_with_from_brackets(___3)) + end | __Stack]. + +-compile({inline,yeccpars2_257_/1}). +-dialyzer({nowarn_function, yeccpars2_257_/1}). +-compile({nowarn_unused_function, yeccpars2_257_/1}). +-file("src/future_elixir_parser.yrl", 145). +yeccpars2_257_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_259_/1}). +-dialyzer({nowarn_function, yeccpars2_259_/1}). +-compile({nowarn_unused_function, yeccpars2_259_/1}). +-file("src/future_elixir_parser.yrl", 291). +yeccpars2_259_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_parens(___1, ___2, {[], []}) + end | __Stack]. + +-compile({inline,yeccpars2_260_/1}). +-dialyzer({nowarn_function, yeccpars2_260_/1}). +-compile({nowarn_unused_function, yeccpars2_260_/1}). +-file("src/future_elixir_parser.yrl", 292). +yeccpars2_260_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_nested_parens(___1, ___2, ___3, {[], []}) + end | __Stack]. + +-compile({inline,yeccpars2_261_/1}). +-dialyzer({nowarn_function, yeccpars2_261_/1}). +-compile({nowarn_unused_function, yeccpars2_261_/1}). +-file("src/future_elixir_parser.yrl", 534). +yeccpars2_261_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_262_/1}). +-dialyzer({nowarn_function, yeccpars2_262_/1}). +-compile({nowarn_unused_function, yeccpars2_262_/1}). +-file("src/future_elixir_parser.yrl", 535). +yeccpars2_262_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + error_no_parens_many_strict(___1) + end | __Stack]. + +-compile({inline,yeccpars2_263_/1}). +-dialyzer({nowarn_function, yeccpars2_263_/1}). +-compile({nowarn_unused_function, yeccpars2_263_/1}). +-file("src/future_elixir_parser.yrl", 533). +yeccpars2_263_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_265_/1}). +-dialyzer({nowarn_function, yeccpars2_265_/1}). +-compile({nowarn_unused_function, yeccpars2_265_/1}). +-file("src/future_elixir_parser.yrl", 563). +yeccpars2_265_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_266_/1}). +-dialyzer({nowarn_function, yeccpars2_266_/1}). +-compile({nowarn_unused_function, yeccpars2_266_/1}). +-file("src/future_elixir_parser.yrl", 537). +yeccpars2_266_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_268_/1}). +-dialyzer({nowarn_function, yeccpars2_268_/1}). +-compile({nowarn_unused_function, yeccpars2_268_/1}). +-file("src/future_elixir_parser.yrl", 540). +yeccpars2_268_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + + {newlines_pair(___1, ___2), []} + end | __Stack]. + +-compile({inline,yeccpars2_269_/1}). +-dialyzer({nowarn_function, yeccpars2_269_/1}). +-compile({nowarn_unused_function, yeccpars2_269_/1}). +-file("src/future_elixir_parser.yrl", 546). +yeccpars2_269_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + {newlines_pair(___1, ___3), reverse(___2)} + end | __Stack]. + +-compile({inline,yeccpars2_270_/1}). +-dialyzer({nowarn_function, yeccpars2_270_/1}). +-compile({nowarn_unused_function, yeccpars2_270_/1}). +-file("src/future_elixir_parser.yrl", 367). +yeccpars2_270_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_273_/1}). +-dialyzer({nowarn_function, yeccpars2_273_/1}). +-compile({nowarn_unused_function, yeccpars2_273_/1}). +-file("src/future_elixir_parser.yrl", 368). +yeccpars2_273_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___2 + end | __Stack]. + +-compile({inline,yeccpars2_274_/1}). +-dialyzer({nowarn_function, yeccpars2_274_/1}). +-compile({nowarn_unused_function, yeccpars2_274_/1}). +-file("src/future_elixir_parser.yrl", 535). +yeccpars2_274_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + error_no_parens_many_strict(___1) + end | __Stack]. + +-compile({inline,yeccpars2_276_/1}). +-dialyzer({nowarn_function, yeccpars2_276_/1}). +-compile({nowarn_unused_function, yeccpars2_276_/1}). +-file("src/future_elixir_parser.yrl", 538). +yeccpars2_276_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3 | ___1] + end | __Stack]. + +-compile({inline,yeccpars2_277_/1}). +-dialyzer({nowarn_function, yeccpars2_277_/1}). +-compile({nowarn_unused_function, yeccpars2_277_/1}). +-file("src/future_elixir_parser.yrl", 548). +yeccpars2_277_(__Stack0) -> + [___5,___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + + {newlines_pair(___1, ___5), reverse([___4 | ___2])} + end | __Stack]. + +-compile({inline,yeccpars2_278_/1}). +-dialyzer({nowarn_function, yeccpars2_278_/1}). +-compile({nowarn_unused_function, yeccpars2_278_/1}). +-file("src/future_elixir_parser.yrl", 564). +yeccpars2_278_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + warn_trailing_comma(___2), reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_279_/1}). +-dialyzer({nowarn_function, yeccpars2_279_/1}). +-compile({nowarn_unused_function, yeccpars2_279_/1}). +-file("src/future_elixir_parser.yrl", 565). +yeccpars2_279_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + maybe_bad_keyword_call_follow_up(___2, ___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_280_/1}). +-dialyzer({nowarn_function, yeccpars2_280_/1}). +-compile({nowarn_unused_function, yeccpars2_280_/1}). +-file("src/future_elixir_parser.yrl", 544). +yeccpars2_280_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + {newlines_pair(___1, ___3), [___2]} + end | __Stack]. + +-compile({inline,yeccpars2_281_/1}). +-dialyzer({nowarn_function, yeccpars2_281_/1}). +-compile({nowarn_unused_function, yeccpars2_281_/1}). +-file("src/future_elixir_parser.yrl", 542). +yeccpars2_281_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + {newlines_pair(___1, ___3), [___2]} + end | __Stack]. + +-compile({inline,yeccpars2_282_/1}). +-dialyzer({nowarn_function, yeccpars2_282_/1}). +-compile({nowarn_unused_function, yeccpars2_282_/1}). +-file("src/future_elixir_parser.yrl", 500). +yeccpars2_282_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_284_/1}). +-dialyzer({nowarn_function, yeccpars2_284_/1}). +-compile({nowarn_unused_function, yeccpars2_284_/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_284_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_285_/1}). +-dialyzer({nowarn_function, yeccpars2_285_/1}). +-compile({nowarn_unused_function, yeccpars2_285_/1}). +-file("src/future_elixir_parser.yrl", 574). +yeccpars2_285_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_286_/1}). +-dialyzer({nowarn_function, yeccpars2_286_/1}). +-compile({nowarn_unused_function, yeccpars2_286_/1}). +-file("src/future_elixir_parser.yrl", 499). +yeccpars2_286_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_288_/1}). +-dialyzer({nowarn_function, yeccpars2_288_/1}). +-compile({nowarn_unused_function, yeccpars2_288_/1}). +-file("src/future_elixir_parser.yrl", 576). +yeccpars2_288_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + maybe_bad_keyword_call_follow_up(___2, [___1], ___3) + end | __Stack]. + +-compile({inline,yeccpars2_289_/1}). +-dialyzer({nowarn_function, yeccpars2_289_/1}). +-compile({nowarn_unused_function, yeccpars2_289_/1}). +-file("src/future_elixir_parser.yrl", 575). +yeccpars2_289_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___1 | ___3] + end | __Stack]. + +-compile({inline,yeccpars2_291_/1}). +-dialyzer({nowarn_function, yeccpars2_291_/1}). +-compile({nowarn_unused_function, yeccpars2_291_/1}). +-file("src/future_elixir_parser.yrl", 572). +yeccpars2_291_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + warn_nested_no_parens_keyword(___1, ___2), {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_292_/1}). +-dialyzer({nowarn_function, yeccpars2_292_/1}). +-compile({nowarn_unused_function, yeccpars2_292_/1}). +-file("src/future_elixir_parser.yrl", 571). +yeccpars2_292_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_294_/1}). +-dialyzer({nowarn_function, yeccpars2_294_/1}). +-compile({nowarn_unused_function, yeccpars2_294_/1}). +-file("src/future_elixir_parser.yrl", 248). +yeccpars2_294_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_identifier(___1) + end | __Stack]. + +-compile({inline,yeccpars2_297_/1}). +-dialyzer({nowarn_function, yeccpars2_297_/1}). +-compile({nowarn_unused_function, yeccpars2_297_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_297_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_298_/1}). +-dialyzer({nowarn_function, yeccpars2_298_/1}). +-compile({nowarn_unused_function, yeccpars2_298_/1}). +-file("src/future_elixir_parser.yrl", 164). +yeccpars2_298_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_299_/1}). +-dialyzer({nowarn_function, yeccpars2_299_/1}). +-compile({nowarn_unused_function, yeccpars2_299_/1}). +-file("src/future_elixir_parser.yrl", 146). +yeccpars2_299_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_318_/1}). +-dialyzer({nowarn_function, yeccpars2_318_/1}). +-compile({nowarn_unused_function, yeccpars2_318_/1}). +-file("src/future_elixir_parser.yrl", 182). +yeccpars2_318_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_319_/1}). +-dialyzer({nowarn_function, yeccpars2_319_/1}). +-compile({nowarn_unused_function, yeccpars2_319_/1}). +-file("src/future_elixir_parser.yrl", 191). +yeccpars2_319_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_320_/1}). +-dialyzer({nowarn_function, yeccpars2_320_/1}). +-compile({nowarn_unused_function, yeccpars2_320_/1}). +-file("src/future_elixir_parser.yrl", 189). +yeccpars2_320_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_321_/1}). +-dialyzer({nowarn_function, yeccpars2_321_/1}). +-compile({nowarn_unused_function, yeccpars2_321_/1}). +-file("src/future_elixir_parser.yrl", 178). +yeccpars2_321_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_322_/1}). +-dialyzer({nowarn_function, yeccpars2_322_/1}). +-compile({nowarn_unused_function, yeccpars2_322_/1}). +-file("src/future_elixir_parser.yrl", 218). +yeccpars2_322_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_323_/1}). +-dialyzer({nowarn_function, yeccpars2_323_/1}). +-compile({nowarn_unused_function, yeccpars2_323_/1}). +-file("src/future_elixir_parser.yrl", 175). +yeccpars2_323_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_324_/1}). +-dialyzer({nowarn_function, yeccpars2_324_/1}). +-compile({nowarn_unused_function, yeccpars2_324_/1}). +-file("src/future_elixir_parser.yrl", 228). +yeccpars2_324_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_325_/1}). +-dialyzer({nowarn_function, yeccpars2_325_/1}). +-compile({nowarn_unused_function, yeccpars2_325_/1}). +-file("src/future_elixir_parser.yrl", 185). +yeccpars2_325_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_326_/1}). +-dialyzer({nowarn_function, yeccpars2_326_/1}). +-compile({nowarn_unused_function, yeccpars2_326_/1}). +-file("src/future_elixir_parser.yrl", 227). +yeccpars2_326_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_327_/1}). +-dialyzer({nowarn_function, yeccpars2_327_/1}). +-compile({nowarn_unused_function, yeccpars2_327_/1}). +-file("src/future_elixir_parser.yrl", 184). +yeccpars2_327_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_328_/1}). +-dialyzer({nowarn_function, yeccpars2_328_/1}). +-compile({nowarn_unused_function, yeccpars2_328_/1}). +-file("src/future_elixir_parser.yrl", 217). +yeccpars2_328_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_329_/1}). +-dialyzer({nowarn_function, yeccpars2_329_/1}). +-compile({nowarn_unused_function, yeccpars2_329_/1}). +-file("src/future_elixir_parser.yrl", 174). +yeccpars2_329_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_330_/1}). +-dialyzer({nowarn_function, yeccpars2_330_/1}). +-compile({nowarn_unused_function, yeccpars2_330_/1}). +-file("src/future_elixir_parser.yrl", 219). +yeccpars2_330_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_331_/1}). +-dialyzer({nowarn_function, yeccpars2_331_/1}). +-compile({nowarn_unused_function, yeccpars2_331_/1}). +-file("src/future_elixir_parser.yrl", 176). +yeccpars2_331_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_332_/1}). +-dialyzer({nowarn_function, yeccpars2_332_/1}). +-compile({nowarn_unused_function, yeccpars2_332_/1}). +-file("src/future_elixir_parser.yrl", 226). +yeccpars2_332_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_333_/1}). +-dialyzer({nowarn_function, yeccpars2_333_/1}). +-compile({nowarn_unused_function, yeccpars2_333_/1}). +-file("src/future_elixir_parser.yrl", 183). +yeccpars2_333_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_334_/1}). +-dialyzer({nowarn_function, yeccpars2_334_/1}). +-compile({nowarn_unused_function, yeccpars2_334_/1}). +-file("src/future_elixir_parser.yrl", 231). +yeccpars2_334_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_335_/1}). +-dialyzer({nowarn_function, yeccpars2_335_/1}). +-compile({nowarn_unused_function, yeccpars2_335_/1}). +-file("src/future_elixir_parser.yrl", 188). +yeccpars2_335_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_336_/1}). +-dialyzer({nowarn_function, yeccpars2_336_/1}). +-compile({nowarn_unused_function, yeccpars2_336_/1}). +-file("src/future_elixir_parser.yrl", 220). +yeccpars2_336_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_337_/1}). +-dialyzer({nowarn_function, yeccpars2_337_/1}). +-compile({nowarn_unused_function, yeccpars2_337_/1}). +-file("src/future_elixir_parser.yrl", 177). +yeccpars2_337_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_338_/1}). +-dialyzer({nowarn_function, yeccpars2_338_/1}). +-compile({nowarn_unused_function, yeccpars2_338_/1}). +-file("src/future_elixir_parser.yrl", 222). +yeccpars2_338_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_339_/1}). +-dialyzer({nowarn_function, yeccpars2_339_/1}). +-compile({nowarn_unused_function, yeccpars2_339_/1}). +-file("src/future_elixir_parser.yrl", 179). +yeccpars2_339_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_340_/1}). +-dialyzer({nowarn_function, yeccpars2_340_/1}). +-compile({nowarn_unused_function, yeccpars2_340_/1}). +-file("src/future_elixir_parser.yrl", 233). +yeccpars2_340_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_341_/1}). +-dialyzer({nowarn_function, yeccpars2_341_/1}). +-compile({nowarn_unused_function, yeccpars2_341_/1}). +-file("src/future_elixir_parser.yrl", 190). +yeccpars2_341_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_342_/1}). +-dialyzer({nowarn_function, yeccpars2_342_/1}). +-compile({nowarn_unused_function, yeccpars2_342_/1}). +-file("src/future_elixir_parser.yrl", 223). +yeccpars2_342_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_343_/1}). +-dialyzer({nowarn_function, yeccpars2_343_/1}). +-compile({nowarn_unused_function, yeccpars2_343_/1}). +-file("src/future_elixir_parser.yrl", 180). +yeccpars2_343_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_344_/1}). +-dialyzer({nowarn_function, yeccpars2_344_/1}). +-compile({nowarn_unused_function, yeccpars2_344_/1}). +-file("src/future_elixir_parser.yrl", 229). +yeccpars2_344_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_345_/1}). +-dialyzer({nowarn_function, yeccpars2_345_/1}). +-compile({nowarn_unused_function, yeccpars2_345_/1}). +-file("src/future_elixir_parser.yrl", 186). +yeccpars2_345_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_346_/1}). +-dialyzer({nowarn_function, yeccpars2_346_/1}). +-compile({nowarn_unused_function, yeccpars2_346_/1}). +-file("src/future_elixir_parser.yrl", 230). +yeccpars2_346_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_347_/1}). +-dialyzer({nowarn_function, yeccpars2_347_/1}). +-compile({nowarn_unused_function, yeccpars2_347_/1}). +-file("src/future_elixir_parser.yrl", 187). +yeccpars2_347_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_348_/1}). +-dialyzer({nowarn_function, yeccpars2_348_/1}). +-compile({nowarn_unused_function, yeccpars2_348_/1}). +-file("src/future_elixir_parser.yrl", 237). +yeccpars2_348_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_349_/1}). +-dialyzer({nowarn_function, yeccpars2_349_/1}). +-compile({nowarn_unused_function, yeccpars2_349_/1}). +-file("src/future_elixir_parser.yrl", 224). +yeccpars2_349_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_350_/1}). +-dialyzer({nowarn_function, yeccpars2_350_/1}). +-compile({nowarn_unused_function, yeccpars2_350_/1}). +-file("src/future_elixir_parser.yrl", 181). +yeccpars2_350_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_351_/1}). +-dialyzer({nowarn_function, yeccpars2_351_/1}). +-compile({nowarn_unused_function, yeccpars2_351_/1}). +-file("src/future_elixir_parser.yrl", 162). +yeccpars2_351_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_352_/1}). +-dialyzer({nowarn_function, yeccpars2_352_/1}). +-compile({nowarn_unused_function, yeccpars2_352_/1}). +-file("src/future_elixir_parser.yrl", 144). +yeccpars2_352_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_353_/1}). +-dialyzer({nowarn_function, yeccpars2_353_/1}). +-compile({nowarn_unused_function, yeccpars2_353_/1}). +-file("src/future_elixir_parser.yrl", 163). +yeccpars2_353_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_354_/1}). +-dialyzer({nowarn_function, yeccpars2_354_/1}). +-compile({nowarn_unused_function, yeccpars2_354_/1}). +-file("src/future_elixir_parser.yrl", 145). +yeccpars2_354_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_356_/1}). +-dialyzer({nowarn_function, yeccpars2_356_/1}). +-compile({nowarn_unused_function, yeccpars2_356_/1}). +-file("src/future_elixir_parser.yrl", 505). +yeccpars2_356_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_357_/1}). +-dialyzer({nowarn_function, yeccpars2_357_/1}). +-compile({nowarn_unused_function, yeccpars2_357_/1}). +-file("src/future_elixir_parser.yrl", 500). +yeccpars2_357_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_358_/1}). +-dialyzer({nowarn_function, yeccpars2_358_/1}). +-compile({nowarn_unused_function, yeccpars2_358_/1}). +-file("src/future_elixir_parser.yrl", 243). +yeccpars2_358_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_359_/1}). +-dialyzer({nowarn_function, yeccpars2_359_/1}). +-compile({nowarn_unused_function, yeccpars2_359_/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_359_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_360_/1}). +-dialyzer({nowarn_function, yeccpars2_360_/1}). +-compile({nowarn_unused_function, yeccpars2_360_/1}). +-file("src/future_elixir_parser.yrl", 508). +yeccpars2_360_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_361_/1}). +-dialyzer({nowarn_function, yeccpars2_361_/1}). +-compile({nowarn_unused_function, yeccpars2_361_/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_361_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_363_/1}). +-dialyzer({nowarn_function, yeccpars2_363_/1}). +-compile({nowarn_unused_function, yeccpars2_363_/1}). +-file("src/future_elixir_parser.yrl", 490). +yeccpars2_363_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + error_no_parens_many_strict(___1) + end | __Stack]. + +-compile({inline,yeccpars2_364_/1}). +-dialyzer({nowarn_function, yeccpars2_364_/1}). +-compile({nowarn_unused_function, yeccpars2_364_/1}). +-file("src/future_elixir_parser.yrl", 489). +yeccpars2_364_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_365_/1}). +-dialyzer({nowarn_function, yeccpars2_365_/1}). +-compile({nowarn_unused_function, yeccpars2_365_/1}). +-file("src/future_elixir_parser.yrl", 509). +yeccpars2_365_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + reverse([___3 | ___1]) + end | __Stack]. + +-compile({inline,yeccpars2_366_/1}). +-dialyzer({nowarn_function, yeccpars2_366_/1}). +-compile({nowarn_unused_function, yeccpars2_366_/1}). +-file("src/future_elixir_parser.yrl", 493). +yeccpars2_366_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3 | ___1] + end | __Stack]. + +-compile({inline,yeccpars2_368_/1}). +-dialyzer({nowarn_function, yeccpars2_368_/1}). +-compile({nowarn_unused_function, yeccpars2_368_/1}). +-file("src/future_elixir_parser.yrl", 507). +yeccpars2_368_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___1, ___3] + end | __Stack]. + +-compile({inline,yeccpars2_369_/1}). +-dialyzer({nowarn_function, yeccpars2_369_/1}). +-compile({nowarn_unused_function, yeccpars2_369_/1}). +-file("src/future_elixir_parser.yrl", 492). +yeccpars2_369_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3, ___1] + end | __Stack]. + +-compile({inline,yeccpars2_371_/1}). +-dialyzer({nowarn_function, yeccpars2_371_/1}). +-compile({nowarn_unused_function, yeccpars2_371_/1}). +-file("src/future_elixir_parser.yrl", 339). +yeccpars2_371_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + + build_op([], ___1) + end | __Stack]. + +-compile({inline,yeccpars2_372_/1}). +-dialyzer({nowarn_function, yeccpars2_372_/1}). +-compile({nowarn_unused_function, yeccpars2_372_/1}). +-file("src/future_elixir_parser.yrl", 353). +yeccpars2_372_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + warn_empty_stab_clause(___1), {___1, handle_literal(nil, ___1)} + end | __Stack]. + +-compile({inline,yeccpars2_373_/1}). +-dialyzer({nowarn_function, yeccpars2_373_/1}). +-compile({nowarn_unused_function, yeccpars2_373_/1}). +-file("src/future_elixir_parser.yrl", 331). +yeccpars2_373_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_375_/1}). +-dialyzer({nowarn_function, yeccpars2_375_/1}). +-compile({nowarn_unused_function, yeccpars2_375_/1}). +-file("src/future_elixir_parser.yrl", 334). +yeccpars2_375_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_377_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_377_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_377_)'/1}). +-file("src/future_elixir_parser.yrl", 100). +'yeccpars2_377_)'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_377_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_377_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_377_;'/1}). +-file("src/future_elixir_parser.yrl", 100). +'yeccpars2_377_;'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_377_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_377_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_377_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 100). +yeccpars2_377_block_identifier(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_377_end/1}). +-dialyzer({nowarn_function, yeccpars2_377_end/1}). +-compile({nowarn_unused_function, yeccpars2_377_end/1}). +-file("src/future_elixir_parser.yrl", 100). +yeccpars2_377_end(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_377_eol/1}). +-dialyzer({nowarn_function, yeccpars2_377_eol/1}). +-compile({nowarn_unused_function, yeccpars2_377_eol/1}). +-file("src/future_elixir_parser.yrl", 100). +yeccpars2_377_eol(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_377_/1}). +-dialyzer({nowarn_function, yeccpars2_377_/1}). +-compile({nowarn_unused_function, yeccpars2_377_/1}). +-file("src/future_elixir_parser.yrl", 505). +yeccpars2_377_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,'yeccpars2_378_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_378_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_378_)'/1}). +-file("src/future_elixir_parser.yrl", 99). +'yeccpars2_378_)'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_378_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_378_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_378_;'/1}). +-file("src/future_elixir_parser.yrl", 99). +'yeccpars2_378_;'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_378_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_378_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_378_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 99). +yeccpars2_378_block_identifier(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_378_end/1}). +-dialyzer({nowarn_function, yeccpars2_378_end/1}). +-compile({nowarn_unused_function, yeccpars2_378_end/1}). +-file("src/future_elixir_parser.yrl", 99). +yeccpars2_378_end(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_378_eol/1}). +-dialyzer({nowarn_function, yeccpars2_378_eol/1}). +-compile({nowarn_unused_function, yeccpars2_378_eol/1}). +-file("src/future_elixir_parser.yrl", 99). +yeccpars2_378_eol(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_378_/1}). +-dialyzer({nowarn_function, yeccpars2_378_/1}). +-compile({nowarn_unused_function, yeccpars2_378_/1}). +-file("src/future_elixir_parser.yrl", 500). +yeccpars2_378_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_379_/1}). +-dialyzer({nowarn_function, yeccpars2_379_/1}). +-compile({nowarn_unused_function, yeccpars2_379_/1}). +-file("src/future_elixir_parser.yrl", 337). +yeccpars2_379_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_380_/1}). +-dialyzer({nowarn_function, yeccpars2_380_/1}). +-compile({nowarn_unused_function, yeccpars2_380_/1}). +-file("src/future_elixir_parser.yrl", 267). +yeccpars2_380_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + warn_empty_paren(___1), {'__block__', [], []} + end | __Stack]. + +-compile({inline,yeccpars2_381_/1}). +-dialyzer({nowarn_function, yeccpars2_381_/1}). +-compile({nowarn_unused_function, yeccpars2_381_/1}). +-file("src/future_elixir_parser.yrl", 495). +yeccpars2_381_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_382_/1}). +-dialyzer({nowarn_function, yeccpars2_382_/1}). +-compile({nowarn_unused_function, yeccpars2_382_/1}). +-file("src/future_elixir_parser.yrl", 497). +yeccpars2_382_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_383_/1}). +-dialyzer({nowarn_function, yeccpars2_383_/1}). +-compile({nowarn_unused_function, yeccpars2_383_/1}). +-file("src/future_elixir_parser.yrl", 499). +yeccpars2_383_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_384_/1}). +-dialyzer({nowarn_function, yeccpars2_384_/1}). +-compile({nowarn_unused_function, yeccpars2_384_/1}). +-file("src/future_elixir_parser.yrl", 496). +yeccpars2_384_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_386_/1}). +-dialyzer({nowarn_function, yeccpars2_386_/1}). +-compile({nowarn_unused_function, yeccpars2_386_/1}). +-file("src/future_elixir_parser.yrl", 370). +yeccpars2_386_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_388_/1}). +-dialyzer({nowarn_function, yeccpars2_388_/1}). +-compile({nowarn_unused_function, yeccpars2_388_/1}). +-file("src/future_elixir_parser.yrl", 447). +yeccpars2_388_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_389_/1}). +-dialyzer({nowarn_function, yeccpars2_389_/1}). +-compile({nowarn_unused_function, yeccpars2_389_/1}). +-file("src/future_elixir_parser.yrl", 448). +yeccpars2_389_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_391_/1}). +-dialyzer({nowarn_function, yeccpars2_391_/1}). +-compile({nowarn_unused_function, yeccpars2_391_/1}). +-file("src/future_elixir_parser.yrl", 266). +yeccpars2_391_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_paren_stab(___1, [], ___3) + end | __Stack]. + +-compile({inline,yeccpars2_392_/1}). +-dialyzer({nowarn_function, yeccpars2_392_/1}). +-compile({nowarn_unused_function, yeccpars2_392_/1}). +-file("src/future_elixir_parser.yrl", 497). +yeccpars2_392_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_393_/1}). +-dialyzer({nowarn_function, yeccpars2_393_/1}). +-compile({nowarn_unused_function, yeccpars2_393_/1}). +-file("src/future_elixir_parser.yrl", 265). +yeccpars2_393_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_paren_stab(___1, ___3, ___4) + end | __Stack]. + +-compile({inline,yeccpars2_394_/1}). +-dialyzer({nowarn_function, yeccpars2_394_/1}). +-compile({nowarn_unused_function, yeccpars2_394_/1}). +-file("src/future_elixir_parser.yrl", 345). +yeccpars2_394_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + + build_op(unwrap_when(unwrap_splice(___1)), ___2) + end | __Stack]. + +-compile({inline,yeccpars2_395_/1}). +-dialyzer({nowarn_function, yeccpars2_395_/1}). +-compile({nowarn_unused_function, yeccpars2_395_/1}). +-file("src/future_elixir_parser.yrl", 512). +yeccpars2_395_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + error_no_parens_strict(___1) + end | __Stack]. + +-compile({inline,yeccpars2_396_/1}). +-dialyzer({nowarn_function, yeccpars2_396_/1}). +-compile({nowarn_unused_function, yeccpars2_396_/1}). +-file("src/future_elixir_parser.yrl", 513). +yeccpars2_396_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + error_no_parens_strict(___1) + end | __Stack]. + +-compile({inline,yeccpars2_397_/1}). +-dialyzer({nowarn_function, yeccpars2_397_/1}). +-compile({nowarn_unused_function, yeccpars2_397_/1}). +-file("src/future_elixir_parser.yrl", 341). +yeccpars2_397_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + + build_op([], ___2) + end | __Stack]. + +-compile({inline,yeccpars2_400_/1}). +-dialyzer({nowarn_function, yeccpars2_400_/1}). +-compile({nowarn_unused_function, yeccpars2_400_/1}). +-file("src/future_elixir_parser.yrl", 343). +yeccpars2_400_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + + build_op([{'when', meta_from_token(___2), [___3]}], ___4) + end | __Stack]. + +-compile({inline,yeccpars2_401_/1}). +-dialyzer({nowarn_function, yeccpars2_401_/1}). +-compile({nowarn_unused_function, yeccpars2_401_/1}). +-file("src/future_elixir_parser.yrl", 497). +yeccpars2_401_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_402_/1}). +-dialyzer({nowarn_function, yeccpars2_402_/1}). +-compile({nowarn_unused_function, yeccpars2_402_/1}). +-file("src/future_elixir_parser.yrl", 499). +yeccpars2_402_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_403_/1}). +-dialyzer({nowarn_function, yeccpars2_403_/1}). +-compile({nowarn_unused_function, yeccpars2_403_/1}). +-file("src/future_elixir_parser.yrl", 515). +yeccpars2_403_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___2] + end | __Stack]. + +-compile({inline,yeccpars2_404_/1}). +-dialyzer({nowarn_function, yeccpars2_404_/1}). +-compile({nowarn_unused_function, yeccpars2_404_/1}). +-file("src/future_elixir_parser.yrl", 516). +yeccpars2_404_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + ___2 + end | __Stack]. + +-compile({inline,yeccpars2_405_/1}). +-dialyzer({nowarn_function, yeccpars2_405_/1}). +-compile({nowarn_unused_function, yeccpars2_405_/1}). +-file("src/future_elixir_parser.yrl", 335). +yeccpars2_405_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + annotate_eoe(___2, ___1) + end | __Stack]. + +-compile({inline,yeccpars2_406_/1}). +-dialyzer({nowarn_function, yeccpars2_406_/1}). +-compile({nowarn_unused_function, yeccpars2_406_/1}). +-file("src/future_elixir_parser.yrl", 332). +yeccpars2_406_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3 | annotate_eoe(___2, ___1)] + end | __Stack]. + +-compile({inline,yeccpars2_407_/1}). +-dialyzer({nowarn_function, yeccpars2_407_/1}). +-compile({nowarn_unused_function, yeccpars2_407_/1}). +-file("src/future_elixir_parser.yrl", 264). +yeccpars2_407_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_paren_stab(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_408_/1}). +-dialyzer({nowarn_function, yeccpars2_408_/1}). +-compile({nowarn_unused_function, yeccpars2_408_/1}). +-file("src/future_elixir_parser.yrl", 352). +yeccpars2_408_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_409_/1}). +-dialyzer({nowarn_function, yeccpars2_409_/1}). +-compile({nowarn_unused_function, yeccpars2_409_/1}). +-file("src/future_elixir_parser.yrl", 347). +yeccpars2_409_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + + build_op(unwrap_splice(___1), ___2) + end | __Stack]. + +-compile({inline,yeccpars2_412_/1}). +-dialyzer({nowarn_function, yeccpars2_412_/1}). +-compile({nowarn_unused_function, yeccpars2_412_/1}). +-file("src/future_elixir_parser.yrl", 349). +yeccpars2_412_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + + build_op([{'when', meta_from_token(___2), unwrap_splice(___1) ++ [___3]}], ___4) + end | __Stack]. + +-compile({inline,yeccpars2_413_/1}). +-dialyzer({nowarn_function, yeccpars2_413_/1}). +-compile({nowarn_unused_function, yeccpars2_413_/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_413_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_414_/1}). +-dialyzer({nowarn_function, yeccpars2_414_/1}). +-compile({nowarn_unused_function, yeccpars2_414_/1}). +-file("src/future_elixir_parser.yrl", 242). +yeccpars2_414_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_415_/1}). +-dialyzer({nowarn_function, yeccpars2_415_/1}). +-compile({nowarn_unused_function, yeccpars2_415_/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_415_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_416_/1}). +-dialyzer({nowarn_function, yeccpars2_416_/1}). +-compile({nowarn_unused_function, yeccpars2_416_/1}). +-file("src/future_elixir_parser.yrl", 161). +yeccpars2_416_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_417_/1}). +-dialyzer({nowarn_function, yeccpars2_417_/1}). +-compile({nowarn_unused_function, yeccpars2_417_/1}). +-file("src/future_elixir_parser.yrl", 143). +yeccpars2_417_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_418_/1}). +-dialyzer({nowarn_function, yeccpars2_418_/1}). +-compile({nowarn_unused_function, yeccpars2_418_/1}). +-file("src/future_elixir_parser.yrl", 561). +yeccpars2_418_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + [{___3, ___4} | ___1] + end | __Stack]. + +-compile({inline,yeccpars2_419_/1}). +-dialyzer({nowarn_function, yeccpars2_419_/1}). +-compile({nowarn_unused_function, yeccpars2_419_/1}). +-file("src/future_elixir_parser.yrl", 143). +yeccpars2_419_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_420_/1}). +-dialyzer({nowarn_function, yeccpars2_420_/1}). +-compile({nowarn_unused_function, yeccpars2_420_/1}). +-file("src/future_elixir_parser.yrl", 560). +yeccpars2_420_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + [{___1, ___2}] + end | __Stack]. + +-compile({inline,yeccpars2_421_/1}). +-dialyzer({nowarn_function, yeccpars2_421_/1}). +-compile({nowarn_unused_function, yeccpars2_421_/1}). +-file("src/future_elixir_parser.yrl", 199). +yeccpars2_421_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_422_/1}). +-dialyzer({nowarn_function, yeccpars2_422_/1}). +-compile({nowarn_unused_function, yeccpars2_422_/1}). +-file("src/future_elixir_parser.yrl", 175). +yeccpars2_422_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_423_/1}). +-dialyzer({nowarn_function, yeccpars2_423_/1}). +-compile({nowarn_unused_function, yeccpars2_423_/1}). +-file("src/future_elixir_parser.yrl", 209). +yeccpars2_423_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_424_/1}). +-dialyzer({nowarn_function, yeccpars2_424_/1}). +-compile({nowarn_unused_function, yeccpars2_424_/1}). +-file("src/future_elixir_parser.yrl", 185). +yeccpars2_424_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_425_/1}). +-dialyzer({nowarn_function, yeccpars2_425_/1}). +-compile({nowarn_unused_function, yeccpars2_425_/1}). +-file("src/future_elixir_parser.yrl", 208). +yeccpars2_425_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_426_/1}). +-dialyzer({nowarn_function, yeccpars2_426_/1}). +-compile({nowarn_unused_function, yeccpars2_426_/1}). +-file("src/future_elixir_parser.yrl", 184). +yeccpars2_426_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_427_/1}). +-dialyzer({nowarn_function, yeccpars2_427_/1}). +-compile({nowarn_unused_function, yeccpars2_427_/1}). +-file("src/future_elixir_parser.yrl", 198). +yeccpars2_427_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_428_/1}). +-dialyzer({nowarn_function, yeccpars2_428_/1}). +-compile({nowarn_unused_function, yeccpars2_428_/1}). +-file("src/future_elixir_parser.yrl", 174). +yeccpars2_428_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_429_/1}). +-dialyzer({nowarn_function, yeccpars2_429_/1}). +-compile({nowarn_unused_function, yeccpars2_429_/1}). +-file("src/future_elixir_parser.yrl", 200). +yeccpars2_429_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_430_/1}). +-dialyzer({nowarn_function, yeccpars2_430_/1}). +-compile({nowarn_unused_function, yeccpars2_430_/1}). +-file("src/future_elixir_parser.yrl", 176). +yeccpars2_430_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_431_/1}). +-dialyzer({nowarn_function, yeccpars2_431_/1}). +-compile({nowarn_unused_function, yeccpars2_431_/1}). +-file("src/future_elixir_parser.yrl", 207). +yeccpars2_431_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_432_/1}). +-dialyzer({nowarn_function, yeccpars2_432_/1}). +-compile({nowarn_unused_function, yeccpars2_432_/1}). +-file("src/future_elixir_parser.yrl", 183). +yeccpars2_432_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_433_/1}). +-dialyzer({nowarn_function, yeccpars2_433_/1}). +-compile({nowarn_unused_function, yeccpars2_433_/1}). +-file("src/future_elixir_parser.yrl", 212). +yeccpars2_433_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_434_/1}). +-dialyzer({nowarn_function, yeccpars2_434_/1}). +-compile({nowarn_unused_function, yeccpars2_434_/1}). +-file("src/future_elixir_parser.yrl", 188). +yeccpars2_434_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_435_/1}). +-dialyzer({nowarn_function, yeccpars2_435_/1}). +-compile({nowarn_unused_function, yeccpars2_435_/1}). +-file("src/future_elixir_parser.yrl", 201). +yeccpars2_435_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_436_/1}). +-dialyzer({nowarn_function, yeccpars2_436_/1}). +-compile({nowarn_unused_function, yeccpars2_436_/1}). +-file("src/future_elixir_parser.yrl", 177). +yeccpars2_436_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_437_/1}). +-dialyzer({nowarn_function, yeccpars2_437_/1}). +-compile({nowarn_unused_function, yeccpars2_437_/1}). +-file("src/future_elixir_parser.yrl", 203). +yeccpars2_437_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_438_/1}). +-dialyzer({nowarn_function, yeccpars2_438_/1}). +-compile({nowarn_unused_function, yeccpars2_438_/1}). +-file("src/future_elixir_parser.yrl", 179). +yeccpars2_438_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_439_/1}). +-dialyzer({nowarn_function, yeccpars2_439_/1}). +-compile({nowarn_unused_function, yeccpars2_439_/1}). +-file("src/future_elixir_parser.yrl", 214). +yeccpars2_439_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_440_/1}). +-dialyzer({nowarn_function, yeccpars2_440_/1}). +-compile({nowarn_unused_function, yeccpars2_440_/1}). +-file("src/future_elixir_parser.yrl", 190). +yeccpars2_440_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_441_/1}). +-dialyzer({nowarn_function, yeccpars2_441_/1}). +-compile({nowarn_unused_function, yeccpars2_441_/1}). +-file("src/future_elixir_parser.yrl", 204). +yeccpars2_441_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_442_/1}). +-dialyzer({nowarn_function, yeccpars2_442_/1}). +-compile({nowarn_unused_function, yeccpars2_442_/1}). +-file("src/future_elixir_parser.yrl", 180). +yeccpars2_442_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_443_/1}). +-dialyzer({nowarn_function, yeccpars2_443_/1}). +-compile({nowarn_unused_function, yeccpars2_443_/1}). +-file("src/future_elixir_parser.yrl", 210). +yeccpars2_443_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_444_/1}). +-dialyzer({nowarn_function, yeccpars2_444_/1}). +-compile({nowarn_unused_function, yeccpars2_444_/1}). +-file("src/future_elixir_parser.yrl", 186). +yeccpars2_444_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_445_/1}). +-dialyzer({nowarn_function, yeccpars2_445_/1}). +-compile({nowarn_unused_function, yeccpars2_445_/1}). +-file("src/future_elixir_parser.yrl", 211). +yeccpars2_445_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_446_/1}). +-dialyzer({nowarn_function, yeccpars2_446_/1}). +-compile({nowarn_unused_function, yeccpars2_446_/1}). +-file("src/future_elixir_parser.yrl", 187). +yeccpars2_446_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_447_/1}). +-dialyzer({nowarn_function, yeccpars2_447_/1}). +-compile({nowarn_unused_function, yeccpars2_447_/1}). +-file("src/future_elixir_parser.yrl", 205). +yeccpars2_447_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_448_/1}). +-dialyzer({nowarn_function, yeccpars2_448_/1}). +-compile({nowarn_unused_function, yeccpars2_448_/1}). +-file("src/future_elixir_parser.yrl", 181). +yeccpars2_448_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_449_/1}). +-dialyzer({nowarn_function, yeccpars2_449_/1}). +-compile({nowarn_unused_function, yeccpars2_449_/1}). +-file("src/future_elixir_parser.yrl", 392). +yeccpars2_449_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_450_/1}). +-dialyzer({nowarn_function, yeccpars2_450_/1}). +-compile({nowarn_unused_function, yeccpars2_450_/1}). +-file("src/future_elixir_parser.yrl", 397). +yeccpars2_450_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_451_/1}). +-dialyzer({nowarn_function, yeccpars2_451_/1}). +-compile({nowarn_unused_function, yeccpars2_451_/1}). +-file("src/future_elixir_parser.yrl", 262). +yeccpars2_451_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, number_value(___2)) + end | __Stack]. + +-compile({inline,yeccpars2_452_/1}). +-dialyzer({nowarn_function, yeccpars2_452_/1}). +-compile({nowarn_unused_function, yeccpars2_452_/1}). +-file("src/future_elixir_parser.yrl", 400). +yeccpars2_452_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_453_/1}). +-dialyzer({nowarn_function, yeccpars2_453_/1}). +-compile({nowarn_unused_function, yeccpars2_453_/1}). +-file("src/future_elixir_parser.yrl", 373). +yeccpars2_453_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_454_/1}). +-dialyzer({nowarn_function, yeccpars2_454_/1}). +-compile({nowarn_unused_function, yeccpars2_454_/1}). +-file("src/future_elixir_parser.yrl", 378). +yeccpars2_454_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_455_/1}). +-dialyzer({nowarn_function, yeccpars2_455_/1}). +-compile({nowarn_unused_function, yeccpars2_455_/1}). +-file("src/future_elixir_parser.yrl", 366). +yeccpars2_455_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + next_is_eol(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_456_/1}). +-dialyzer({nowarn_function, yeccpars2_456_/1}). +-compile({nowarn_unused_function, yeccpars2_456_/1}). +-file("src/future_elixir_parser.yrl", 629). +yeccpars2_456_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_458_,'/1}). +-dialyzer({nowarn_function, 'yeccpars2_458_,'/1}). +-compile({nowarn_unused_function, 'yeccpars2_458_,'/1}). +-file("src/future_elixir_parser.yrl", 602). +'yeccpars2_458_,'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_458_eol/1}). +-dialyzer({nowarn_function, yeccpars2_458_eol/1}). +-compile({nowarn_unused_function, yeccpars2_458_eol/1}). +-file("src/future_elixir_parser.yrl", 602). +yeccpars2_458_eol(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_458_{'/1}). +-dialyzer({nowarn_function, 'yeccpars2_458_{'/1}). +-compile({nowarn_unused_function, 'yeccpars2_458_{'/1}). +-file("src/future_elixir_parser.yrl", 602). +'yeccpars2_458_{'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_458_}'/1}). +-dialyzer({nowarn_function, 'yeccpars2_458_}'/1}). +-compile({nowarn_unused_function, 'yeccpars2_458_}'/1}). +-file("src/future_elixir_parser.yrl", 602). +'yeccpars2_458_}'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_458_/1}). +-dialyzer({nowarn_function, yeccpars2_458_/1}). +-compile({nowarn_unused_function, yeccpars2_458_/1}). +-file("src/future_elixir_parser.yrl", 148). +yeccpars2_458_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_462_/1}). +-dialyzer({nowarn_function, yeccpars2_462_/1}). +-compile({nowarn_unused_function, yeccpars2_462_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_462_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_463_/1}). +-dialyzer({nowarn_function, yeccpars2_463_/1}). +-compile({nowarn_unused_function, yeccpars2_463_/1}). +-file("src/future_elixir_parser.yrl", 605). +yeccpars2_463_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_464_/1}). +-dialyzer({nowarn_function, yeccpars2_464_/1}). +-compile({nowarn_unused_function, yeccpars2_464_/1}). +-file("src/future_elixir_parser.yrl", 603). +yeccpars2_464_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_466_/1}). +-dialyzer({nowarn_function, yeccpars2_466_/1}). +-compile({nowarn_unused_function, yeccpars2_466_/1}). +-file("src/future_elixir_parser.yrl", 643). +yeccpars2_466_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {'%', meta_from_token(___1), [___2, ___3]} + end | __Stack]. + +-compile({inline,yeccpars2_468_/1}). +-dialyzer({nowarn_function, yeccpars2_468_/1}). +-compile({nowarn_unused_function, yeccpars2_468_/1}). +-file("src/future_elixir_parser.yrl", 644). +yeccpars2_468_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + {'%', meta_from_token(___1), [___2, ___4]} + end | __Stack]. + +-compile({inline,yeccpars2_472_/1}). +-dialyzer({nowarn_function, yeccpars2_472_/1}). +-compile({nowarn_unused_function, yeccpars2_472_/1}). +-file("src/future_elixir_parser.yrl", 636). +yeccpars2_472_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_map(___1, element(1, ___2), element(2, ___2)) + end | __Stack]. + +-compile({inline,yeccpars2_473_/1}). +-dialyzer({nowarn_function, yeccpars2_473_/1}). +-compile({nowarn_unused_function, yeccpars2_473_/1}). +-file("src/future_elixir_parser.yrl", 614). +yeccpars2_473_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_476_/1}). +-dialyzer({nowarn_function, yeccpars2_476_/1}). +-compile({nowarn_unused_function, yeccpars2_476_/1}). +-file("src/future_elixir_parser.yrl", 248). +yeccpars2_476_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_identifier(___1) + end | __Stack]. + +-compile({inline,yeccpars2_481_/1}). +-dialyzer({nowarn_function, yeccpars2_481_/1}). +-compile({nowarn_unused_function, yeccpars2_481_/1}). +-file("src/future_elixir_parser.yrl", 622). +yeccpars2_481_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-compile({inline,yeccpars2_482_/1}). +-dialyzer({nowarn_function, yeccpars2_482_/1}). +-compile({nowarn_unused_function, yeccpars2_482_/1}). +-file("src/future_elixir_parser.yrl", 625). +yeccpars2_482_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_484_/1}). +-dialyzer({nowarn_function, yeccpars2_484_/1}). +-compile({nowarn_unused_function, yeccpars2_484_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_484_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_485_/1}). +-dialyzer({nowarn_function, yeccpars2_485_/1}). +-compile({nowarn_unused_function, yeccpars2_485_/1}). +-file("src/future_elixir_parser.yrl", 635). +yeccpars2_485_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_map(___1, [], ___2) + end | __Stack]. + +-compile({inline,yeccpars2_488_/1}). +-dialyzer({nowarn_function, yeccpars2_488_/1}). +-compile({nowarn_unused_function, yeccpars2_488_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_488_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_489_/1}). +-dialyzer({nowarn_function, yeccpars2_489_/1}). +-compile({nowarn_unused_function, yeccpars2_489_/1}). +-file("src/future_elixir_parser.yrl", 162). +yeccpars2_489_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_490_/1}). +-dialyzer({nowarn_function, yeccpars2_490_/1}). +-compile({nowarn_unused_function, yeccpars2_490_/1}). +-file("src/future_elixir_parser.yrl", 144). +yeccpars2_490_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_491_/1}). +-dialyzer({nowarn_function, yeccpars2_491_/1}). +-compile({nowarn_unused_function, yeccpars2_491_/1}). +-file("src/future_elixir_parser.yrl", 155). +yeccpars2_491_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_492_/1}). +-dialyzer({nowarn_function, yeccpars2_492_/1}). +-compile({nowarn_unused_function, yeccpars2_492_/1}). +-file("src/future_elixir_parser.yrl", 161). +yeccpars2_492_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_493_/1}). +-dialyzer({nowarn_function, yeccpars2_493_/1}). +-compile({nowarn_unused_function, yeccpars2_493_/1}). +-file("src/future_elixir_parser.yrl", 143). +yeccpars2_493_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_494_/1}). +-dialyzer({nowarn_function, yeccpars2_494_/1}). +-compile({nowarn_unused_function, yeccpars2_494_/1}). +-file("src/future_elixir_parser.yrl", 604). +yeccpars2_494_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_495_/1}). +-dialyzer({nowarn_function, yeccpars2_495_/1}). +-compile({nowarn_unused_function, yeccpars2_495_/1}). +-file("src/future_elixir_parser.yrl", 154). +yeccpars2_495_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_496_/1}). +-dialyzer({nowarn_function, yeccpars2_496_/1}). +-compile({nowarn_unused_function, yeccpars2_496_/1}). +-file("src/future_elixir_parser.yrl", 632). +yeccpars2_496_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_497_/1}). +-dialyzer({nowarn_function, yeccpars2_497_/1}). +-compile({nowarn_unused_function, yeccpars2_497_/1}). +-file("src/future_elixir_parser.yrl", 626). +yeccpars2_497_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_501_/1}). +-dialyzer({nowarn_function, yeccpars2_501_/1}). +-compile({nowarn_unused_function, yeccpars2_501_/1}). +-file("src/future_elixir_parser.yrl", 623). +yeccpars2_501_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3 | ___1] + end | __Stack]. + +-compile({inline,yeccpars2_502_/1}). +-dialyzer({nowarn_function, yeccpars2_502_/1}). +-compile({nowarn_unused_function, yeccpars2_502_/1}). +-file("src/future_elixir_parser.yrl", 633). +yeccpars2_502_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + {reverse(___1, ___3), ___4} + end | __Stack]. + +-compile({inline,yeccpars2_522_/1}). +-dialyzer({nowarn_function, yeccpars2_522_/1}). +-compile({nowarn_unused_function, yeccpars2_522_/1}). +-file("src/future_elixir_parser.yrl", 607). +yeccpars2_522_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_523_/1}). +-dialyzer({nowarn_function, yeccpars2_523_/1}). +-compile({nowarn_unused_function, yeccpars2_523_/1}). +-file("src/future_elixir_parser.yrl", 608). +yeccpars2_523_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_525_/1}). +-dialyzer({nowarn_function, yeccpars2_525_/1}). +-compile({nowarn_unused_function, yeccpars2_525_/1}). +-file("src/future_elixir_parser.yrl", 182). +yeccpars2_525_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_527_/1}). +-dialyzer({nowarn_function, yeccpars2_527_/1}). +-compile({nowarn_unused_function, yeccpars2_527_/1}). +-file("src/future_elixir_parser.yrl", 252). +yeccpars2_527_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + build_nullary_op(___1) + end | __Stack]. + +-compile({inline,yeccpars2_528_/1}). +-dialyzer({nowarn_function, yeccpars2_528_/1}). +-compile({nowarn_unused_function, yeccpars2_528_/1}). +-file("src/future_elixir_parser.yrl", 191). +yeccpars2_528_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_529_/1}). +-dialyzer({nowarn_function, yeccpars2_529_/1}). +-compile({nowarn_unused_function, yeccpars2_529_/1}). +-file("src/future_elixir_parser.yrl", 612). +yeccpars2_529_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___3} + end | __Stack]. + +-compile({inline,yeccpars2_530_/1}). +-dialyzer({nowarn_function, yeccpars2_530_/1}). +-compile({nowarn_unused_function, yeccpars2_530_/1}). +-file("src/future_elixir_parser.yrl", 610). +yeccpars2_530_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___3} + end | __Stack]. + +-compile({inline,yeccpars2_531_/1}). +-dialyzer({nowarn_function, yeccpars2_531_/1}). +-compile({nowarn_unused_function, yeccpars2_531_/1}). +-file("src/future_elixir_parser.yrl", 189). +yeccpars2_531_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_532_/1}). +-dialyzer({nowarn_function, yeccpars2_532_/1}). +-compile({nowarn_unused_function, yeccpars2_532_/1}). +-file("src/future_elixir_parser.yrl", 178). +yeccpars2_532_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_533_/1}). +-dialyzer({nowarn_function, yeccpars2_533_/1}). +-compile({nowarn_unused_function, yeccpars2_533_/1}). +-file("src/future_elixir_parser.yrl", 175). +yeccpars2_533_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_534_/1}). +-dialyzer({nowarn_function, yeccpars2_534_/1}). +-compile({nowarn_unused_function, yeccpars2_534_/1}). +-file("src/future_elixir_parser.yrl", 185). +yeccpars2_534_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_535_/1}). +-dialyzer({nowarn_function, yeccpars2_535_/1}). +-compile({nowarn_unused_function, yeccpars2_535_/1}). +-file("src/future_elixir_parser.yrl", 184). +yeccpars2_535_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_536_/1}). +-dialyzer({nowarn_function, yeccpars2_536_/1}). +-compile({nowarn_unused_function, yeccpars2_536_/1}). +-file("src/future_elixir_parser.yrl", 174). +yeccpars2_536_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_537_/1}). +-dialyzer({nowarn_function, yeccpars2_537_/1}). +-compile({nowarn_unused_function, yeccpars2_537_/1}). +-file("src/future_elixir_parser.yrl", 176). +yeccpars2_537_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_538_/1}). +-dialyzer({nowarn_function, yeccpars2_538_/1}). +-compile({nowarn_unused_function, yeccpars2_538_/1}). +-file("src/future_elixir_parser.yrl", 183). +yeccpars2_538_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_539_/1}). +-dialyzer({nowarn_function, yeccpars2_539_/1}). +-compile({nowarn_unused_function, yeccpars2_539_/1}). +-file("src/future_elixir_parser.yrl", 188). +yeccpars2_539_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_540_/1}). +-dialyzer({nowarn_function, yeccpars2_540_/1}). +-compile({nowarn_unused_function, yeccpars2_540_/1}). +-file("src/future_elixir_parser.yrl", 177). +yeccpars2_540_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_541_/1}). +-dialyzer({nowarn_function, yeccpars2_541_/1}). +-compile({nowarn_unused_function, yeccpars2_541_/1}). +-file("src/future_elixir_parser.yrl", 179). +yeccpars2_541_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_542_/1}). +-dialyzer({nowarn_function, yeccpars2_542_/1}). +-compile({nowarn_unused_function, yeccpars2_542_/1}). +-file("src/future_elixir_parser.yrl", 190). +yeccpars2_542_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_543_/1}). +-dialyzer({nowarn_function, yeccpars2_543_/1}). +-compile({nowarn_unused_function, yeccpars2_543_/1}). +-file("src/future_elixir_parser.yrl", 180). +yeccpars2_543_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_544_/1}). +-dialyzer({nowarn_function, yeccpars2_544_/1}). +-compile({nowarn_unused_function, yeccpars2_544_/1}). +-file("src/future_elixir_parser.yrl", 186). +yeccpars2_544_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_545_/1}). +-dialyzer({nowarn_function, yeccpars2_545_/1}). +-compile({nowarn_unused_function, yeccpars2_545_/1}). +-file("src/future_elixir_parser.yrl", 187). +yeccpars2_545_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_546_/1}). +-dialyzer({nowarn_function, yeccpars2_546_/1}). +-compile({nowarn_unused_function, yeccpars2_546_/1}). +-file("src/future_elixir_parser.yrl", 181). +yeccpars2_546_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_548_/1}). +-dialyzer({nowarn_function, yeccpars2_548_/1}). +-compile({nowarn_unused_function, yeccpars2_548_/1}). +-file("src/future_elixir_parser.yrl", 611). +yeccpars2_548_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___3} + end | __Stack]. + +-compile({inline,yeccpars2_549_/1}). +-dialyzer({nowarn_function, yeccpars2_549_/1}). +-compile({nowarn_unused_function, yeccpars2_549_/1}). +-file("src/future_elixir_parser.yrl", 613). +yeccpars2_549_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___3} + end | __Stack]. + +-compile({inline,yeccpars2_550_/1}). +-dialyzer({nowarn_function, yeccpars2_550_/1}). +-compile({nowarn_unused_function, yeccpars2_550_/1}). +-file("src/future_elixir_parser.yrl", 637). +yeccpars2_550_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_map_update(___1, ___2, ___3, []) + end | __Stack]. + +-compile({inline,yeccpars2_552_/1}). +-dialyzer({nowarn_function, yeccpars2_552_/1}). +-compile({nowarn_unused_function, yeccpars2_552_/1}). +-file("src/future_elixir_parser.yrl", 639). +yeccpars2_552_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_map_update(___1, ___2, element(2, ___4), element(1, ___4)) + end | __Stack]. + +-compile({inline,yeccpars2_553_/1}). +-dialyzer({nowarn_function, yeccpars2_553_/1}). +-compile({nowarn_unused_function, yeccpars2_553_/1}). +-file("src/future_elixir_parser.yrl", 638). +yeccpars2_553_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_map_update(___1, ___2, ___4, []) + end | __Stack]. + +-compile({inline,yeccpars2_554_/1}). +-dialyzer({nowarn_function, yeccpars2_554_/1}). +-compile({nowarn_unused_function, yeccpars2_554_/1}). +-file("src/future_elixir_parser.yrl", 640). +yeccpars2_554_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_map_update(___1, ___2, ___3, []) + end | __Stack]. + +-compile({inline,yeccpars2_555_/1}). +-dialyzer({nowarn_function, yeccpars2_555_/1}). +-compile({nowarn_unused_function, yeccpars2_555_/1}). +-file("src/future_elixir_parser.yrl", 145). +yeccpars2_555_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_556_/1}). +-dialyzer({nowarn_function, yeccpars2_556_/1}). +-compile({nowarn_unused_function, yeccpars2_556_/1}). +-file("src/future_elixir_parser.yrl", 156). +yeccpars2_556_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_$end'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_$end'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_$end'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_$end'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_)'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_)'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_,'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_,'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_,'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_,'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_.'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_.'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_.'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_.'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_;'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_;'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_>>'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_>>'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_>>'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_>>'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_]'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_]'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_]'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_]'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_and_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_and_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_and_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_and_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_arrow_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_arrow_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_arrow_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_arrow_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_assoc_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_assoc_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_assoc_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_assoc_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_557_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_557_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_block_identifier(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_comp_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_comp_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_comp_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_comp_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_concat_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_concat_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_concat_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_concat_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_dot_call_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_dot_call_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_dot_call_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_dot_call_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_dual_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_dual_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_dual_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_dual_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_end/1}). +-dialyzer({nowarn_function, yeccpars2_557_end/1}). +-compile({nowarn_unused_function, yeccpars2_557_end/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_end(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_eol/1}). +-dialyzer({nowarn_function, yeccpars2_557_eol/1}). +-compile({nowarn_unused_function, yeccpars2_557_eol/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_eol(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_in_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_in_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_in_match_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_in_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_in_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_in_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_in_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_in_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_match_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_mult_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_mult_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_mult_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_mult_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_or_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_or_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_or_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_or_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_pipe_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_pipe_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_pipe_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_pipe_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_power_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_power_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_power_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_power_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_range_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_range_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_range_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_range_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_rel_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_rel_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_rel_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_rel_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_stab_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_stab_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_stab_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_stab_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_ternary_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_ternary_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_ternary_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_ternary_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_type_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_type_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_type_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_type_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_when_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_when_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_when_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_when_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_xor_op/1}). +-dialyzer({nowarn_function, yeccpars2_557_xor_op/1}). +-compile({nowarn_unused_function, yeccpars2_557_xor_op/1}). +-file("src/future_elixir_parser.yrl", 246). +yeccpars2_557_xor_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_557_}'/1}). +-dialyzer({nowarn_function, 'yeccpars2_557_}'/1}). +-compile({nowarn_unused_function, 'yeccpars2_557_}'/1}). +-file("src/future_elixir_parser.yrl", 246). +'yeccpars2_557_}'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_557_/1}). +-dialyzer({nowarn_function, yeccpars2_557_/1}). +-compile({nowarn_unused_function, yeccpars2_557_/1}). +-file("src/future_elixir_parser.yrl", 495). +yeccpars2_557_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_560_/1}). +-dialyzer({nowarn_function, yeccpars2_560_/1}). +-compile({nowarn_unused_function, yeccpars2_560_/1}). +-file("src/future_elixir_parser.yrl", 172). +yeccpars2_560_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens_do_block(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_561_/1}). +-dialyzer({nowarn_function, yeccpars2_561_/1}). +-compile({nowarn_unused_function, yeccpars2_561_/1}). +-file("src/future_elixir_parser.yrl", 325). +yeccpars2_561_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_562_/1}). +-dialyzer({nowarn_function, yeccpars2_562_/1}). +-compile({nowarn_unused_function, yeccpars2_562_/1}). +-file("src/future_elixir_parser.yrl", 326). +yeccpars2_562_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_565_/1}). +-dialyzer({nowarn_function, yeccpars2_565_/1}). +-compile({nowarn_unused_function, yeccpars2_565_/1}). +-file("src/future_elixir_parser.yrl", 360). +yeccpars2_565_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + [___1] + end | __Stack]. + +-file("src/future_elixir_parser.erl", 31857). +-compile({inline,yeccpars2_566_/1}). +-dialyzer({nowarn_function, yeccpars2_566_/1}). +-compile({nowarn_unused_function, yeccpars2_566_/1}). +-file("src/future_elixir_parser.yrl", 357). +yeccpars2_566_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + + {handle_literal(?exprs(___1), ___1), {'__block__', [], []}} + end | __Stack]. + +-compile({inline,yeccpars2_567_/1}). +-dialyzer({nowarn_function, yeccpars2_567_/1}). +-compile({nowarn_unused_function, yeccpars2_567_/1}). +-file("src/future_elixir_parser.yrl", 328). +yeccpars2_567_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_568_/1}). +-dialyzer({nowarn_function, yeccpars2_568_/1}). +-compile({nowarn_unused_function, yeccpars2_568_/1}). +-file("src/future_elixir_parser.yrl", 309). +yeccpars2_568_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + + {do_end_meta(___1, ___2), [[{handle_literal(do, ___1), {'__block__', [], []}}]]} + end | __Stack]. + +-compile({inline,yeccpars2_569_/1}). +-dialyzer({nowarn_function, yeccpars2_569_/1}). +-compile({nowarn_unused_function, yeccpars2_569_/1}). +-file("src/future_elixir_parser.yrl", 329). +yeccpars2_569_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-file("src/future_elixir_parser.erl", 31900). +-compile({inline,yeccpars2_570_/1}). +-dialyzer({nowarn_function, yeccpars2_570_/1}). +-compile({nowarn_unused_function, yeccpars2_570_/1}). +-file("src/future_elixir_parser.yrl", 355). +yeccpars2_570_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + + {handle_literal(?exprs(___1), ___1), build_stab(___2)} + end | __Stack]. + +-compile({inline,yeccpars2_571_/1}). +-dialyzer({nowarn_function, yeccpars2_571_/1}). +-compile({nowarn_unused_function, yeccpars2_571_/1}). +-file("src/future_elixir_parser.yrl", 361). +yeccpars2_571_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + [___1 | ___2] + end | __Stack]. + +-compile({inline,yeccpars2_572_/1}). +-dialyzer({nowarn_function, yeccpars2_572_/1}). +-compile({nowarn_unused_function, yeccpars2_572_/1}). +-file("src/future_elixir_parser.yrl", 313). +yeccpars2_572_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + {do_end_meta(___1, ___3), [[{handle_literal(do, ___1), {'__block__', [], []}} | ___2]]} + end | __Stack]. + +-compile({inline,yeccpars2_574_/1}). +-dialyzer({nowarn_function, yeccpars2_574_/1}). +-compile({nowarn_unused_function, yeccpars2_574_/1}). +-file("src/future_elixir_parser.yrl", 311). +yeccpars2_574_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + + {do_end_meta(___1, ___3), [[{handle_literal(do, ___1), build_stab(___2)}]]} + end | __Stack]. + +-compile({inline,yeccpars2_575_/1}). +-dialyzer({nowarn_function, yeccpars2_575_/1}). +-compile({nowarn_unused_function, yeccpars2_575_/1}). +-file("src/future_elixir_parser.yrl", 315). +yeccpars2_575_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + + {do_end_meta(___1, ___4), [[{handle_literal(do, ___1), build_stab(___2)} | ___3]]} + end | __Stack]. + +-compile({inline,'yeccpars2_576_$end'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_$end'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_$end'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_$end'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_)'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_)'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_,'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_,'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_,'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_,'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_.'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_.'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_.'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_.'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_;'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_;'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_>>'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_>>'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_>>'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_>>'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_]'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_]'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_]'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_]'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_and_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_and_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_and_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_and_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_arrow_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_arrow_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_arrow_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_arrow_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_assoc_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_assoc_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_assoc_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_assoc_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_576_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_576_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_block_identifier(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_comp_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_comp_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_comp_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_comp_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_concat_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_concat_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_concat_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_concat_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_dot_call_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_dot_call_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_dot_call_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_dot_call_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_dual_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_dual_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_dual_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_dual_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_end/1}). +-dialyzer({nowarn_function, yeccpars2_576_end/1}). +-compile({nowarn_unused_function, yeccpars2_576_end/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_end(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_eol/1}). +-dialyzer({nowarn_function, yeccpars2_576_eol/1}). +-compile({nowarn_unused_function, yeccpars2_576_eol/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_eol(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_in_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_in_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_in_match_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_in_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_in_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_in_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_in_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_in_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_match_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_mult_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_mult_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_mult_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_mult_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_or_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_or_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_or_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_or_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_pipe_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_pipe_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_pipe_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_pipe_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_power_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_power_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_power_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_power_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_range_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_range_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_range_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_range_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_rel_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_rel_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_rel_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_rel_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_stab_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_stab_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_stab_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_stab_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_ternary_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_ternary_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_ternary_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_ternary_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_type_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_type_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_type_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_type_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_when_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_when_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_when_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_when_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_xor_op/1}). +-dialyzer({nowarn_function, yeccpars2_576_xor_op/1}). +-compile({nowarn_unused_function, yeccpars2_576_xor_op/1}). +-file("src/future_elixir_parser.yrl", 245). +yeccpars2_576_xor_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_576_}'/1}). +-dialyzer({nowarn_function, 'yeccpars2_576_}'/1}). +-compile({nowarn_unused_function, 'yeccpars2_576_}'/1}). +-file("src/future_elixir_parser.yrl", 245). +'yeccpars2_576_}'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_576_/1}). +-dialyzer({nowarn_function, yeccpars2_576_/1}). +-compile({nowarn_unused_function, yeccpars2_576_/1}). +-file("src/future_elixir_parser.yrl", 495). +yeccpars2_576_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_578_/1}). +-dialyzer({nowarn_function, yeccpars2_578_/1}). +-compile({nowarn_unused_function, yeccpars2_578_/1}). +-file("src/future_elixir_parser.yrl", 171). +yeccpars2_578_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens_do_block(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_579_/1}). +-dialyzer({nowarn_function, yeccpars2_579_/1}). +-compile({nowarn_unused_function, yeccpars2_579_/1}). +-file("src/future_elixir_parser.yrl", 631). +yeccpars2_579_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_581_/1}). +-dialyzer({nowarn_function, yeccpars2_581_/1}). +-compile({nowarn_unused_function, yeccpars2_581_/1}). +-file("src/future_elixir_parser.yrl", 212). +yeccpars2_581_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_582_/1}). +-dialyzer({nowarn_function, yeccpars2_582_/1}). +-compile({nowarn_unused_function, yeccpars2_582_/1}). +-file("src/future_elixir_parser.yrl", 188). +yeccpars2_582_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_583_/1}). +-dialyzer({nowarn_function, yeccpars2_583_/1}). +-compile({nowarn_unused_function, yeccpars2_583_/1}). +-file("src/future_elixir_parser.yrl", 619). +yeccpars2_583_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___2, ___1, ___3} + end | __Stack]. + +-compile({inline,yeccpars2_584_/1}). +-dialyzer({nowarn_function, yeccpars2_584_/1}). +-compile({nowarn_unused_function, yeccpars2_584_/1}). +-file("src/future_elixir_parser.yrl", 616). +yeccpars2_584_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___2, ___1, [___3]} + end | __Stack]. + +-compile({inline,yeccpars2_586_/1}). +-dialyzer({nowarn_function, yeccpars2_586_/1}). +-compile({nowarn_unused_function, yeccpars2_586_/1}). +-file("src/future_elixir_parser.yrl", 188). +yeccpars2_586_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + {___1, ___2} + end | __Stack]. + +-compile({inline,yeccpars2_587_/1}). +-dialyzer({nowarn_function, yeccpars2_587_/1}). +-compile({nowarn_unused_function, yeccpars2_587_/1}). +-file("src/future_elixir_parser.yrl", 620). +yeccpars2_587_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___2, ___1, ___3} + end | __Stack]. + +-compile({inline,yeccpars2_588_/1}). +-dialyzer({nowarn_function, yeccpars2_588_/1}). +-compile({nowarn_unused_function, yeccpars2_588_/1}). +-file("src/future_elixir_parser.yrl", 617). +yeccpars2_588_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + {___2, ___1, [___3]} + end | __Stack]. + +-compile({inline,yeccpars2_589_/1}). +-dialyzer({nowarn_function, yeccpars2_589_/1}). +-compile({nowarn_unused_function, yeccpars2_589_/1}). +-file("src/future_elixir_parser.yrl", 300). +yeccpars2_589_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_access(___1, meta_with_from_brackets(___2)) + end | __Stack]. + +-compile({inline,yeccpars2_590_/1}). +-dialyzer({nowarn_function, yeccpars2_590_/1}). +-compile({nowarn_unused_function, yeccpars2_590_/1}). +-file("src/future_elixir_parser.yrl", 163). +yeccpars2_590_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_unary_op(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_591_/1}). +-dialyzer({nowarn_function, yeccpars2_591_/1}). +-compile({nowarn_unused_function, yeccpars2_591_/1}). +-file("src/future_elixir_parser.yrl", 299). +yeccpars2_591_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_access(build_identifier(___1), meta_with_from_brackets(___2)) + end | __Stack]. + +-compile({inline,yeccpars2_592_/1}). +-dialyzer({nowarn_function, yeccpars2_592_/1}). +-compile({nowarn_unused_function, yeccpars2_592_/1}). +-file("src/future_elixir_parser.yrl", 291). +yeccpars2_592_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_parens(___1, ___2, {[], []}) + end | __Stack]. + +-compile({inline,yeccpars2_593_/1}). +-dialyzer({nowarn_function, yeccpars2_593_/1}). +-compile({nowarn_unused_function, yeccpars2_593_/1}). +-file("src/future_elixir_parser.yrl", 168). +yeccpars2_593_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_parens(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_594_/1}). +-dialyzer({nowarn_function, yeccpars2_594_/1}). +-compile({nowarn_unused_function, yeccpars2_594_/1}). +-file("src/future_elixir_parser.yrl", 292). +yeccpars2_594_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_nested_parens(___1, ___2, ___3, {[], []}) + end | __Stack]. + +-compile({inline,yeccpars2_595_/1}). +-dialyzer({nowarn_function, yeccpars2_595_/1}). +-compile({nowarn_unused_function, yeccpars2_595_/1}). +-file("src/future_elixir_parser.yrl", 169). +yeccpars2_595_(__Stack0) -> + [___4,___3,___2,___1 | __Stack] = __Stack0, + [begin + build_nested_parens(___1, ___2, ___3, ___4) + end | __Stack]. + +-compile({inline,yeccpars2_596_/1}). +-dialyzer({nowarn_function, yeccpars2_596_/1}). +-compile({nowarn_unused_function, yeccpars2_596_/1}). +-file("src/future_elixir_parser.yrl", 170). +yeccpars2_596_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens_do_block(___1, [], ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_597_$end'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_$end'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_$end'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_$end'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_597_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_)'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_)'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_597_,'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_,'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_,'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_,'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_597_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_;'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_;'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_597_>>'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_>>'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_>>'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_>>'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_597_]'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_]'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_]'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_]'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_and_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_and_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_and_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_and_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_arrow_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_arrow_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_arrow_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_arrow_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_assoc_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_assoc_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_assoc_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_assoc_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_597_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_597_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_block_identifier(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_comp_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_comp_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_comp_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_comp_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_concat_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_concat_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_concat_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_concat_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_dual_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_dual_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_dual_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_dual_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_end/1}). +-dialyzer({nowarn_function, yeccpars2_597_end/1}). +-compile({nowarn_unused_function, yeccpars2_597_end/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_end(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_eol/1}). +-dialyzer({nowarn_function, yeccpars2_597_eol/1}). +-compile({nowarn_unused_function, yeccpars2_597_eol/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_eol(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_in_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_in_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_in_match_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_in_match_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_in_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_in_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_in_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_in_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_match_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_match_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_mult_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_mult_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_mult_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_mult_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_or_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_or_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_or_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_or_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_pipe_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_pipe_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_pipe_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_pipe_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_power_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_power_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_power_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_power_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_range_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_range_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_range_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_range_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_rel_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_rel_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_rel_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_rel_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_stab_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_stab_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_stab_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_stab_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_ternary_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_ternary_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_ternary_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_ternary_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_type_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_type_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_type_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_type_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_when_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_when_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_when_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_when_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_xor_op/1}). +-dialyzer({nowarn_function, yeccpars2_597_xor_op/1}). +-compile({nowarn_unused_function, yeccpars2_597_xor_op/1}). +-file("src/future_elixir_parser.yrl", 511). +yeccpars2_597_xor_op(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_597_}'/1}). +-dialyzer({nowarn_function, 'yeccpars2_597_}'/1}). +-compile({nowarn_unused_function, 'yeccpars2_597_}'/1}). +-file("src/future_elixir_parser.yrl", 511). +'yeccpars2_597_}'(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_597_/1}). +-dialyzer({nowarn_function, yeccpars2_597_/1}). +-compile({nowarn_unused_function, yeccpars2_597_/1}). +-file("src/future_elixir_parser.yrl", 497). +yeccpars2_597_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_598_$end'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_$end'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_$end'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_$end'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_598_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_)'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_)'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_598_,'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_,'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_,'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_,'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_598_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_;'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_;'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_598_>>'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_>>'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_>>'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_>>'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_598_]'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_]'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_]'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_]'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_and_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_and_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_and_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_and_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_arrow_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_arrow_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_arrow_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_arrow_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_assoc_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_assoc_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_assoc_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_assoc_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_598_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_598_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_block_identifier(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_comp_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_comp_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_comp_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_comp_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_concat_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_concat_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_concat_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_concat_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_dual_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_dual_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_dual_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_dual_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_end/1}). +-dialyzer({nowarn_function, yeccpars2_598_end/1}). +-compile({nowarn_unused_function, yeccpars2_598_end/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_end(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_eol/1}). +-dialyzer({nowarn_function, yeccpars2_598_eol/1}). +-compile({nowarn_unused_function, yeccpars2_598_eol/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_eol(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_in_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_in_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_in_match_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_in_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_in_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_in_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_in_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_in_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_match_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_mult_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_mult_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_mult_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_mult_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_or_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_or_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_or_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_or_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_pipe_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_pipe_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_pipe_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_pipe_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_power_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_power_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_power_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_power_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_range_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_range_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_range_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_range_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_rel_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_rel_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_rel_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_rel_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_stab_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_stab_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_stab_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_stab_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_ternary_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_ternary_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_ternary_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_ternary_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_type_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_type_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_type_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_type_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_when_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_when_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_when_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_when_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_xor_op/1}). +-dialyzer({nowarn_function, yeccpars2_598_xor_op/1}). +-compile({nowarn_unused_function, yeccpars2_598_xor_op/1}). +-file("src/future_elixir_parser.yrl", 240). +yeccpars2_598_xor_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_598_}'/1}). +-dialyzer({nowarn_function, 'yeccpars2_598_}'/1}). +-compile({nowarn_unused_function, 'yeccpars2_598_}'/1}). +-file("src/future_elixir_parser.yrl", 240). +'yeccpars2_598_}'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_598_/1}). +-dialyzer({nowarn_function, yeccpars2_598_/1}). +-compile({nowarn_unused_function, yeccpars2_598_/1}). +-file("src/future_elixir_parser.yrl", 496). +yeccpars2_598_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,'yeccpars2_599_$end'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_$end'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_$end'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_$end'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_599_)'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_)'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_)'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_)'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_599_,'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_,'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_,'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_,'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_599_;'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_;'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_;'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_;'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_599_>>'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_>>'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_>>'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_>>'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_599_]'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_]'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_]'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_]'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_and_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_and_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_and_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_and_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_arrow_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_arrow_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_arrow_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_arrow_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_assoc_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_assoc_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_assoc_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_assoc_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_block_identifier/1}). +-dialyzer({nowarn_function, yeccpars2_599_block_identifier/1}). +-compile({nowarn_unused_function, yeccpars2_599_block_identifier/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_block_identifier(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_comp_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_comp_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_comp_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_comp_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_concat_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_concat_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_concat_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_concat_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_dual_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_dual_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_dual_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_dual_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_end/1}). +-dialyzer({nowarn_function, yeccpars2_599_end/1}). +-compile({nowarn_unused_function, yeccpars2_599_end/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_end(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_eol/1}). +-dialyzer({nowarn_function, yeccpars2_599_eol/1}). +-compile({nowarn_unused_function, yeccpars2_599_eol/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_eol(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_in_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_in_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_in_match_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_in_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_in_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_in_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_in_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_in_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_match_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_match_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_match_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_match_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_mult_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_mult_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_mult_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_mult_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_or_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_or_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_or_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_or_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_pipe_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_pipe_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_pipe_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_pipe_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_power_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_power_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_power_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_power_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_range_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_range_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_range_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_range_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_rel_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_rel_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_rel_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_rel_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_stab_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_stab_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_stab_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_stab_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_ternary_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_ternary_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_ternary_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_ternary_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_type_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_type_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_type_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_type_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_when_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_when_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_when_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_when_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_xor_op/1}). +-dialyzer({nowarn_function, yeccpars2_599_xor_op/1}). +-compile({nowarn_unused_function, yeccpars2_599_xor_op/1}). +-file("src/future_elixir_parser.yrl", 239). +yeccpars2_599_xor_op(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,'yeccpars2_599_}'/1}). +-dialyzer({nowarn_function, 'yeccpars2_599_}'/1}). +-compile({nowarn_unused_function, 'yeccpars2_599_}'/1}). +-file("src/future_elixir_parser.yrl", 239). +'yeccpars2_599_}'(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_no_parens(___1, ___2) + end | __Stack]. + +-compile({inline,yeccpars2_599_/1}). +-dialyzer({nowarn_function, yeccpars2_599_/1}). +-compile({nowarn_unused_function, yeccpars2_599_/1}). +-file("src/future_elixir_parser.yrl", 496). +yeccpars2_599_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_600_/1}). +-dialyzer({nowarn_function, yeccpars2_600_/1}). +-compile({nowarn_unused_function, yeccpars2_600_/1}). +-file("src/future_elixir_parser.yrl", 90). +yeccpars2_600_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_block(reverse(___2)) + end | __Stack]. + +-compile({inline,yeccpars2_601_/1}). +-dialyzer({nowarn_function, yeccpars2_601_/1}). +-compile({nowarn_unused_function, yeccpars2_601_/1}). +-file("src/future_elixir_parser.yrl", 92). +yeccpars2_601_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_block(reverse(annotate_eoe(___3, ___2))) + end | __Stack]. + +-compile({inline,yeccpars2_602_/1}). +-dialyzer({nowarn_function, yeccpars2_602_/1}). +-compile({nowarn_unused_function, yeccpars2_602_/1}). +-file("src/future_elixir_parser.yrl", 97). +yeccpars2_602_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + [___3 | annotate_eoe(___2, ___1)] + end | __Stack]. + +-compile({inline,yeccpars2_603_/1}). +-dialyzer({nowarn_function, yeccpars2_603_/1}). +-compile({nowarn_unused_function, yeccpars2_603_/1}). +-file("src/future_elixir_parser.yrl", 91). +yeccpars2_603_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_block(reverse(annotate_eoe(___2, ___1))) + end | __Stack]. + +-compile({inline,yeccpars2_605_/1}). +-dialyzer({nowarn_function, yeccpars2_605_/1}). +-compile({nowarn_unused_function, yeccpars2_605_/1}). +-file("src/future_elixir_parser.yrl", 263). +yeccpars2_605_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_fn(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_606_/1}). +-dialyzer({nowarn_function, yeccpars2_606_/1}). +-compile({nowarn_unused_function, yeccpars2_606_/1}). +-file("src/future_elixir_parser.yrl", 642). +yeccpars2_606_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + adjust_map_column(___2) + end | __Stack]. + +-compile({inline,yeccpars2_609_/1}). +-dialyzer({nowarn_function, yeccpars2_609_/1}). +-compile({nowarn_unused_function, yeccpars2_609_/1}). +-file("src/future_elixir_parser.yrl", 596). +yeccpars2_609_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_bit(___1, [], ___2) + end | __Stack]. + +-compile({inline,yeccpars2_610_/1}). +-dialyzer({nowarn_function, yeccpars2_610_/1}). +-compile({nowarn_unused_function, yeccpars2_610_/1}). +-file("src/future_elixir_parser.yrl", 598). +yeccpars2_610_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_bit(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_611_/1}). +-dialyzer({nowarn_function, yeccpars2_611_/1}). +-compile({nowarn_unused_function, yeccpars2_611_/1}). +-file("src/future_elixir_parser.yrl", 379). +yeccpars2_611_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_613_/1}). +-dialyzer({nowarn_function, yeccpars2_613_/1}). +-compile({nowarn_unused_function, yeccpars2_613_/1}). +-file("src/future_elixir_parser.yrl", 380). +yeccpars2_613_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + ___2 + end | __Stack]. + +-compile({inline,yeccpars2_614_/1}). +-dialyzer({nowarn_function, yeccpars2_614_/1}). +-compile({nowarn_unused_function, yeccpars2_614_/1}). +-file("src/future_elixir_parser.yrl", 597). +yeccpars2_614_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + bad_keyword(___1, bitstring) + end | __Stack]. + +-compile({inline,yeccpars2_616_/1}). +-dialyzer({nowarn_function, yeccpars2_616_/1}). +-compile({nowarn_unused_function, yeccpars2_616_/1}). +-file("src/future_elixir_parser.yrl", 580). +yeccpars2_616_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + ___1 + end | __Stack]. + +-compile({inline,yeccpars2_617_/1}). +-dialyzer({nowarn_function, yeccpars2_617_/1}). +-compile({nowarn_unused_function, yeccpars2_617_/1}). +-file("src/future_elixir_parser.yrl", 581). +yeccpars2_617_(__Stack0) -> + [___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_618_/1}). +-dialyzer({nowarn_function, yeccpars2_618_/1}). +-compile({nowarn_unused_function, yeccpars2_618_/1}). +-file("src/future_elixir_parser.yrl", 585). +yeccpars2_618_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_list(___1, [], ___2) + end | __Stack]. + +-compile({inline,yeccpars2_619_/1}). +-dialyzer({nowarn_function, yeccpars2_619_/1}). +-compile({nowarn_unused_function, yeccpars2_619_/1}). +-file("src/future_elixir_parser.yrl", 582). +yeccpars2_619_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + reverse(___1) + end | __Stack]. + +-compile({inline,yeccpars2_620_/1}). +-dialyzer({nowarn_function, yeccpars2_620_/1}). +-compile({nowarn_unused_function, yeccpars2_620_/1}). +-file("src/future_elixir_parser.yrl", 583). +yeccpars2_620_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + reverse(___1, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_621_/1}). +-dialyzer({nowarn_function, yeccpars2_621_/1}). +-compile({nowarn_unused_function, yeccpars2_621_/1}). +-file("src/future_elixir_parser.yrl", 586). +yeccpars2_621_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_list(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_624_/1}). +-dialyzer({nowarn_function, yeccpars2_624_/1}). +-compile({nowarn_unused_function, yeccpars2_624_/1}). +-file("src/future_elixir_parser.yrl", 590). +yeccpars2_624_(__Stack0) -> + [___2,___1 | __Stack] = __Stack0, + [begin + build_tuple(___1, [], ___2) + end | __Stack]. + +-compile({inline,yeccpars2_625_/1}). +-dialyzer({nowarn_function, yeccpars2_625_/1}). +-compile({nowarn_unused_function, yeccpars2_625_/1}). +-file("src/future_elixir_parser.yrl", 592). +yeccpars2_625_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + build_tuple(___1, ___2, ___3) + end | __Stack]. + +-compile({inline,yeccpars2_626_/1}). +-dialyzer({nowarn_function, yeccpars2_626_/1}). +-compile({nowarn_unused_function, yeccpars2_626_/1}). +-file("src/future_elixir_parser.yrl", 591). +yeccpars2_626_(__Stack0) -> + [___3,___2,___1 | __Stack] = __Stack0, + [begin + bad_keyword(___1, tuple) + end | __Stack]. + + +-file("src/future_elixir_parser.yrl", 1285). diff --git a/forge/src/future_elixir_parser.yrl b/forge/src/future_elixir_parser.yrl new file mode 100644 index 00000000..804fcb3a --- /dev/null +++ b/forge/src/future_elixir_parser.yrl @@ -0,0 +1,1284 @@ +%% Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/src/elixir_parser.yrl +Nonterminals + grammar expr_list + expr container_expr block_expr access_expr + no_parens_expr no_parens_zero_expr no_parens_one_expr no_parens_one_ambig_expr + bracket_expr bracket_at_expr bracket_arg matched_expr unmatched_expr sub_matched_expr + unmatched_op_expr matched_op_expr no_parens_op_expr no_parens_many_expr + comp_op_eol at_op_eol unary_op_eol and_op_eol or_op_eol capture_op_eol + dual_op_eol mult_op_eol power_op_eol concat_op_eol xor_op_eol pipe_op_eol + stab_op_eol arrow_op_eol match_op_eol when_op_eol in_op_eol in_match_op_eol + type_op_eol rel_op_eol range_op_eol ternary_op_eol + open_paren close_paren empty_paren eoe + list list_args open_bracket close_bracket + tuple open_curly close_curly + bitstring open_bit close_bit + map map_op map_base_expr map_close map_args + assoc_op_eol assoc_expr assoc_base assoc assoc_update assoc_update_kw + container_args_base container_args + call_args_parens_expr call_args_parens_base call_args_parens parens_call + call_args_no_parens_one call_args_no_parens_ambig call_args_no_parens_expr + call_args_no_parens_comma_expr call_args_no_parens_all call_args_no_parens_many + call_args_no_parens_many_strict + stab stab_eoe stab_expr stab_op_eol_and_expr stab_parens_many + kw_eol kw_base kw_data kw_call call_args_no_parens_kw_expr call_args_no_parens_kw + dot_op dot_alias dot_bracket_identifier dot_call_identifier + dot_identifier dot_op_identifier dot_do_identifier dot_paren_identifier + do_block fn_eoe do_eoe block_eoe block_item block_list + . + +Terminals + identifier kw_identifier kw_identifier_safe kw_identifier_unsafe bracket_identifier + paren_identifier do_identifier block_identifier op_identifier + fn 'end' alias + atom atom_quoted atom_safe atom_unsafe bin_string list_string sigil + bin_heredoc list_heredoc + comp_op at_op unary_op and_op or_op arrow_op match_op in_op in_match_op ellipsis_op + type_op dual_op mult_op power_op concat_op range_op xor_op pipe_op stab_op when_op + capture_int capture_op assoc_op rel_op ternary_op dot_call_op + 'true' 'false' 'nil' 'do' eol ';' ',' '.' + '(' ')' '[' ']' '{' '}' '<<' '>>' '%{}' '%' + int flt char + . + +Rootsymbol grammar. + +%% Two shift/reduce conflicts coming from call_args_parens and +%% one coming from empty_paren on stab. +Expect 3. + +%% Changes in ops and precedence should be reflected on: +%% +%% 1. lib/elixir/lib/code/identifier.ex +%% 2. lib/elixir/pages/operators.md +%% 3. lib/iex/lib/iex/evaluator.ex +%% +%% Note though the operator => in practice has lower precedence +%% than all others, its entry in the table is only to support the +%% %{user | foo => bar} syntax. + +Left 5 do. +Right 10 stab_op_eol. %% -> +Left 20 ','. +Left 40 in_match_op_eol. %% <-, \\ (allowed in matches along =) +Right 50 when_op_eol. %% when +Right 60 type_op_eol. %% :: +Right 70 pipe_op_eol. %% | +Right 80 assoc_op_eol. %% => +Nonassoc 90 capture_op_eol. %% & +Nonassoc 90 ellipsis_op. %% ... +Right 100 match_op_eol. %% = +Left 120 or_op_eol. %% ||, |||, or +Left 130 and_op_eol. %% &&, &&&, and +Left 140 comp_op_eol. %% ==, !=, =~, ===, !== +Left 150 rel_op_eol. %% <, >, <=, >= +Left 160 arrow_op_eol. %% |>, <<<, >>>, <<~, ~>>, <~, ~>, <~>, <|> +Left 170 in_op_eol. %% in, not in +Left 180 xor_op_eol. %% ^^^ +Right 190 ternary_op_eol. %% // +Right 200 concat_op_eol. %% ++, --, +++, ---, <> +Right 200 range_op_eol. %% .. +Left 210 dual_op_eol. %% +, - +Left 220 mult_op_eol. %% *, / +Left 230 power_op_eol. %% ** +Nonassoc 300 unary_op_eol. %% +, -, !, ^, not, ~~~ +Left 310 dot_call_op. +Left 310 dot_op. %% . +Nonassoc 320 at_op_eol. %% @ +Nonassoc 330 dot_identifier. + +%%% MAIN FLOW OF EXPRESSIONS + +grammar -> eoe : {'__block__', meta_from_token('$1'), []}. +grammar -> expr_list : build_block(reverse('$1')). +grammar -> eoe expr_list : build_block(reverse('$2')). +grammar -> expr_list eoe : build_block(reverse(annotate_eoe('$2', '$1'))). +grammar -> eoe expr_list eoe : build_block(reverse(annotate_eoe('$3', '$2'))). +grammar -> '$empty' : {'__block__', [], []}. + +% Note expressions are on reverse order +expr_list -> expr : ['$1']. +expr_list -> expr_list eoe expr : ['$3' | annotate_eoe('$2', '$1')]. + +expr -> matched_expr : '$1'. +expr -> no_parens_expr : '$1'. +expr -> unmatched_expr : '$1'. + +%% In Elixir we have three main call syntaxes: with parentheses, +%% without parentheses and with do blocks. They are represented +%% in the AST as matched, no_parens and unmatched. +%% +%% Calls without parentheses are further divided according to how +%% problematic they are: +%% +%% (a) no_parens_one: a call with one unproblematic argument +%% (for example, `f a` or `f g a` and similar) (includes unary operators) +%% +%% (b) no_parens_many: a call with several arguments (for example, `f a, b`) +%% +%% (c) no_parens_one_ambig: a call with one argument which is +%% itself a no_parens_many or no_parens_one_ambig (for example, `f g a, b`, +%% `f g h a, b` and similar) +%% +%% Note, in particular, that no_parens_one_ambig expressions are +%% ambiguous and are interpreted such that the outer function has +%% arity 1. For instance, `f g a, b` is interpreted as `f(g(a, b))` rather +%% than `f(g(a), b)`. Hence the name, no_parens_one_ambig. +%% +%% The distinction is required because we can't, for example, have +%% a function call with a do block as argument inside another do +%% block call, unless there are parentheses: +%% +%% if if true do true else false end do #=> invalid +%% if(if true do true else false end) do #=> valid +%% +%% Similarly, it is not possible to nest calls without parentheses +%% if their arity is more than 1: +%% +%% foo a, bar b, c #=> invalid +%% foo(a, bar b, c) #=> invalid +%% foo bar a, b #=> valid +%% foo a, bar(b, c) #=> valid +%% +%% So the different grammar rules need to take into account +%% if calls without parentheses are do blocks in particular +%% segments and act accordingly. +matched_expr -> matched_expr matched_op_expr : build_op('$1', '$2'). +matched_expr -> unary_op_eol matched_expr : build_unary_op('$1', '$2'). +matched_expr -> at_op_eol matched_expr : build_unary_op('$1', '$2'). +matched_expr -> capture_op_eol matched_expr : build_unary_op('$1', '$2'). +matched_expr -> ellipsis_op matched_expr : build_unary_op('$1', '$2'). +matched_expr -> no_parens_one_expr : '$1'. +matched_expr -> sub_matched_expr : '$1'. + +unmatched_expr -> matched_expr unmatched_op_expr : build_op('$1', '$2'). +unmatched_expr -> unmatched_expr matched_op_expr : build_op('$1', '$2'). +unmatched_expr -> unmatched_expr unmatched_op_expr : build_op('$1', '$2'). +unmatched_expr -> unmatched_expr no_parens_op_expr : warn_no_parens_after_do_op('$2'), build_op('$1', '$2'). +unmatched_expr -> unary_op_eol expr : build_unary_op('$1', '$2'). +unmatched_expr -> at_op_eol expr : build_unary_op('$1', '$2'). +unmatched_expr -> capture_op_eol expr : build_unary_op('$1', '$2'). +unmatched_expr -> ellipsis_op expr : build_unary_op('$1', '$2'). +unmatched_expr -> block_expr : '$1'. + +no_parens_expr -> matched_expr no_parens_op_expr : build_op('$1', '$2'). +no_parens_expr -> unary_op_eol no_parens_expr : build_unary_op('$1', '$2'). +no_parens_expr -> at_op_eol no_parens_expr : build_unary_op('$1', '$2'). +no_parens_expr -> capture_op_eol no_parens_expr : build_unary_op('$1', '$2'). +no_parens_expr -> ellipsis_op no_parens_expr : build_unary_op('$1', '$2'). +no_parens_expr -> no_parens_one_ambig_expr : '$1'. +no_parens_expr -> no_parens_many_expr : '$1'. + +block_expr -> dot_call_identifier call_args_parens do_block : build_parens('$1', '$2', '$3'). +block_expr -> dot_call_identifier call_args_parens call_args_parens do_block : build_nested_parens('$1', '$2', '$3', '$4'). +block_expr -> dot_do_identifier do_block : build_no_parens_do_block('$1', [], '$2'). +block_expr -> dot_op_identifier call_args_no_parens_all do_block : build_no_parens_do_block('$1', '$2', '$3'). +block_expr -> dot_identifier call_args_no_parens_all do_block : build_no_parens_do_block('$1', '$2', '$3'). + +matched_op_expr -> match_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> dual_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> mult_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> power_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> concat_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> range_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> ternary_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> xor_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> and_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> or_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> in_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> in_match_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> type_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> when_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> pipe_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> comp_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> rel_op_eol matched_expr : {'$1', '$2'}. +matched_op_expr -> arrow_op_eol matched_expr : {'$1', '$2'}. + +%% We warn exclusively for |> and friends because they are used +%% in other languages with lower precedence than function application, +%% which can be the source of confusion. +matched_op_expr -> arrow_op_eol no_parens_one_expr : warn_pipe('$1', '$2'), {'$1', '$2'}. + +unmatched_op_expr -> match_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> dual_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> mult_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> power_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> concat_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> range_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> ternary_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> xor_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> and_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> or_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> in_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> in_match_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> type_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> when_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> pipe_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> comp_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> rel_op_eol unmatched_expr : {'$1', '$2'}. +unmatched_op_expr -> arrow_op_eol unmatched_expr : {'$1', '$2'}. + +no_parens_op_expr -> match_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> dual_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> mult_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> power_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> concat_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> range_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> ternary_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> xor_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> and_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> or_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> in_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> in_match_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> type_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> when_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> pipe_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> comp_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> rel_op_eol no_parens_expr : {'$1', '$2'}. +no_parens_op_expr -> arrow_op_eol no_parens_expr : warn_pipe('$1', '$2'), {'$1', '$2'}. + +%% Allow when (and only when) with keywords +no_parens_op_expr -> when_op_eol call_args_no_parens_kw : {'$1', '$2'}. + +no_parens_one_ambig_expr -> dot_op_identifier call_args_no_parens_ambig : build_no_parens('$1', '$2'). +no_parens_one_ambig_expr -> dot_identifier call_args_no_parens_ambig : build_no_parens('$1', '$2'). + +no_parens_many_expr -> dot_op_identifier call_args_no_parens_many_strict : build_no_parens('$1', '$2'). +no_parens_many_expr -> dot_identifier call_args_no_parens_many_strict : build_no_parens('$1', '$2'). + +no_parens_one_expr -> dot_op_identifier call_args_no_parens_one : build_no_parens('$1', '$2'). +no_parens_one_expr -> dot_identifier call_args_no_parens_one : build_no_parens('$1', '$2'). +no_parens_zero_expr -> dot_do_identifier : build_identifier('$1'). +no_parens_zero_expr -> dot_identifier : build_identifier('$1'). + +sub_matched_expr -> no_parens_zero_expr : '$1'. +sub_matched_expr -> range_op : build_nullary_op('$1'). +sub_matched_expr -> ellipsis_op : build_nullary_op('$1'). +sub_matched_expr -> access_expr : '$1'. +sub_matched_expr -> access_expr kw_identifier : error_invalid_kw_identifier('$2'). + +%% From this point on, we just have constructs that can be +%% used with the access syntax. Note that (dot_)identifier +%% is not included in this list simply because the tokenizer +%% marks identifiers followed by brackets as bracket_identifier. +access_expr -> bracket_at_expr : '$1'. +access_expr -> bracket_expr : '$1'. +access_expr -> capture_int int : build_unary_op('$1', number_value('$2')). +access_expr -> fn_eoe stab_eoe 'end' : build_fn('$1', '$2', '$3'). +access_expr -> open_paren stab_eoe ')' : build_paren_stab('$1', '$2', '$3'). +access_expr -> open_paren ';' stab_eoe ')' : build_paren_stab('$1', '$3', '$4'). +access_expr -> open_paren ';' close_paren : build_paren_stab('$1', [], '$3'). +access_expr -> empty_paren : warn_empty_paren('$1'), {'__block__', [], []}. +access_expr -> int : handle_number(number_value('$1'), '$1', ?exprs('$1')). +access_expr -> flt : handle_number(number_value('$1'), '$1', ?exprs('$1')). +access_expr -> char : handle_number(?exprs('$1'), '$1', number_value('$1')). +access_expr -> list : element(1, '$1'). +access_expr -> map : '$1'. +access_expr -> tuple : '$1'. +access_expr -> 'true' : handle_literal(?id('$1'), '$1'). +access_expr -> 'false' : handle_literal(?id('$1'), '$1'). +access_expr -> 'nil' : handle_literal(?id('$1'), '$1'). +access_expr -> bin_string : build_bin_string('$1', delimiter(<<$">>)). +access_expr -> list_string : build_list_string('$1', delimiter(<<$'>>)). +access_expr -> bin_heredoc : build_bin_heredoc('$1'). +access_expr -> list_heredoc : build_list_heredoc('$1'). +access_expr -> bitstring : '$1'. +access_expr -> sigil : build_sigil('$1'). +access_expr -> atom : handle_literal(?exprs('$1'), '$1'). +access_expr -> atom_quoted : handle_literal(?exprs('$1'), '$1', delimiter(<<$">>)). +access_expr -> atom_safe : build_quoted_atom('$1', true, delimiter(<<$">>)). +access_expr -> atom_unsafe : build_quoted_atom('$1', false, delimiter(<<$">>)). +access_expr -> dot_alias : '$1'. +access_expr -> parens_call : '$1'. + +%% Also used by maps and structs +parens_call -> dot_call_identifier call_args_parens : build_parens('$1', '$2', {[], []}). +parens_call -> dot_call_identifier call_args_parens call_args_parens : build_nested_parens('$1', '$2', '$3', {[], []}). + +bracket_arg -> open_bracket kw_data close_bracket : build_access_arg('$1', '$2', '$3'). +bracket_arg -> open_bracket container_expr close_bracket : build_access_arg('$1', '$2', '$3'). +bracket_arg -> open_bracket container_expr ',' close_bracket : build_access_arg('$1', '$2', '$4'). +bracket_arg -> open_bracket container_expr ',' container_args close_bracket : error_too_many_access_syntax('$3'). + +bracket_expr -> dot_bracket_identifier bracket_arg : build_access(build_identifier('$1'), meta_with_from_brackets('$2')). +bracket_expr -> access_expr bracket_arg : build_access('$1', meta_with_from_brackets('$2')). + +bracket_at_expr -> at_op_eol dot_bracket_identifier bracket_arg : + build_access(build_unary_op('$1', build_identifier('$2')), meta_with_from_brackets('$3')). +bracket_at_expr -> at_op_eol access_expr bracket_arg : + build_access(build_unary_op('$1', '$2'), meta_with_from_brackets('$3')). + +%% Blocks + +do_block -> do_eoe 'end' : + {do_end_meta('$1', '$2'), [[{handle_literal(do, '$1'), {'__block__', [], []}}]]}. +do_block -> do_eoe stab_eoe 'end' : + {do_end_meta('$1', '$3'), [[{handle_literal(do, '$1'), build_stab('$2')}]]}. +do_block -> do_eoe block_list 'end' : + {do_end_meta('$1', '$3'), [[{handle_literal(do, '$1'), {'__block__', [], []}} | '$2']]}. +do_block -> do_eoe stab_eoe block_list 'end' : + {do_end_meta('$1', '$4'), [[{handle_literal(do, '$1'), build_stab('$2')} | '$3']]}. + +eoe -> eol : '$1'. +eoe -> ';' : '$1'. +eoe -> eol ';' : '$1'. + +fn_eoe -> 'fn' : '$1'. +fn_eoe -> 'fn' eoe : next_is_eol('$1', '$2'). + +do_eoe -> 'do' : '$1'. +do_eoe -> 'do' eoe : '$1'. + +block_eoe -> block_identifier : '$1'. +block_eoe -> block_identifier eoe : '$1'. + +stab -> stab_expr : ['$1']. +stab -> stab eoe stab_expr : ['$3' | annotate_eoe('$2', '$1')]. + +stab_eoe -> stab : '$1'. +stab_eoe -> stab eoe : annotate_eoe('$2', '$1'). + +stab_expr -> expr : + '$1'. +stab_expr -> stab_op_eol_and_expr : + build_op([], '$1'). +stab_expr -> empty_paren stab_op_eol_and_expr : + build_op([], '$2'). +stab_expr -> empty_paren when_op expr stab_op_eol_and_expr : + build_op([{'when', meta_from_token('$2'), ['$3']}], '$4'). +stab_expr -> call_args_no_parens_all stab_op_eol_and_expr : + build_op(unwrap_when(unwrap_splice('$1')), '$2'). +stab_expr -> stab_parens_many stab_op_eol_and_expr : + build_op(unwrap_splice('$1'), '$2'). +stab_expr -> stab_parens_many when_op expr stab_op_eol_and_expr : + build_op([{'when', meta_from_token('$2'), unwrap_splice('$1') ++ ['$3']}], '$4'). + +stab_op_eol_and_expr -> stab_op_eol expr : {'$1', '$2'}. +stab_op_eol_and_expr -> stab_op_eol : warn_empty_stab_clause('$1'), {'$1', handle_literal(nil, '$1')}. + +block_item -> block_eoe stab_eoe : + {handle_literal(?exprs('$1'), '$1'), build_stab('$2')}. +block_item -> block_eoe : + {handle_literal(?exprs('$1'), '$1'), {'__block__', [], []}}. + +block_list -> block_item : ['$1']. +block_list -> block_item block_list : ['$1' | '$2']. + +%% Helpers + +open_paren -> '(' : '$1'. +open_paren -> '(' eol : next_is_eol('$1', '$2'). +close_paren -> ')' : '$1'. +close_paren -> eol ')' : '$2'. + +empty_paren -> open_paren ')' : '$1'. + +open_bracket -> '[' : '$1'. +open_bracket -> '[' eol : next_is_eol('$1', '$2'). +close_bracket -> ']' : '$1'. +close_bracket -> eol ']' : '$2'. + +open_bit -> '<<' : '$1'. +open_bit -> '<<' eol : next_is_eol('$1', '$2'). +close_bit -> '>>' : '$1'. +close_bit -> eol '>>' : '$2'. + +open_curly -> '{' : '$1'. +open_curly -> '{' eol : next_is_eol('$1', '$2'). +close_curly -> '}' : '$1'. +close_curly -> eol '}' : '$2'. + +% Operators + +unary_op_eol -> unary_op : '$1'. +unary_op_eol -> unary_op eol : '$1'. +unary_op_eol -> dual_op : '$1'. +unary_op_eol -> dual_op eol : '$1'. +unary_op_eol -> ternary_op : '$1'. +unary_op_eol -> ternary_op eol : '$1'. + +capture_op_eol -> capture_op : '$1'. +capture_op_eol -> capture_op eol : '$1'. + +at_op_eol -> at_op : '$1'. +at_op_eol -> at_op eol : '$1'. + +match_op_eol -> match_op : '$1'. +match_op_eol -> match_op eol : next_is_eol('$1', '$2'). + +dual_op_eol -> dual_op : '$1'. +dual_op_eol -> dual_op eol : next_is_eol('$1', '$2'). + +mult_op_eol -> mult_op : '$1'. +mult_op_eol -> mult_op eol : next_is_eol('$1', '$2'). + +power_op_eol -> power_op : '$1'. +power_op_eol -> power_op eol : next_is_eol('$1', '$2'). + +concat_op_eol -> concat_op : '$1'. +concat_op_eol -> concat_op eol : next_is_eol('$1', '$2'). + +range_op_eol -> range_op : '$1'. +range_op_eol -> range_op eol : next_is_eol('$1', '$2'). + +ternary_op_eol -> ternary_op : '$1'. +ternary_op_eol -> ternary_op eol : next_is_eol('$1', '$2'). + +xor_op_eol -> xor_op : '$1'. +xor_op_eol -> xor_op eol : next_is_eol('$1', '$2'). + +pipe_op_eol -> pipe_op : '$1'. +pipe_op_eol -> pipe_op eol : next_is_eol('$1', '$2'). + +and_op_eol -> and_op : '$1'. +and_op_eol -> and_op eol : next_is_eol('$1', '$2'). + +or_op_eol -> or_op : '$1'. +or_op_eol -> or_op eol : next_is_eol('$1', '$2'). + +in_op_eol -> in_op : '$1'. +in_op_eol -> in_op eol : next_is_eol('$1', '$2'). + +in_match_op_eol -> in_match_op : '$1'. +in_match_op_eol -> in_match_op eol : next_is_eol('$1', '$2'). + +type_op_eol -> type_op : '$1'. +type_op_eol -> type_op eol : next_is_eol('$1', '$2'). + +when_op_eol -> when_op : '$1'. +when_op_eol -> when_op eol : next_is_eol('$1', '$2'). + +stab_op_eol -> stab_op : '$1'. +stab_op_eol -> stab_op eol : next_is_eol('$1', '$2'). + +comp_op_eol -> comp_op : '$1'. +comp_op_eol -> comp_op eol : next_is_eol('$1', '$2'). + +rel_op_eol -> rel_op : '$1'. +rel_op_eol -> rel_op eol : next_is_eol('$1', '$2'). + +arrow_op_eol -> arrow_op : '$1'. +arrow_op_eol -> arrow_op eol : next_is_eol('$1', '$2'). + +% Dot operator + +dot_op -> '.' : '$1'. +dot_op -> '.' eol : '$1'. + +dot_identifier -> identifier : '$1'. +dot_identifier -> matched_expr dot_op identifier : build_dot('$2', '$1', '$3'). + +dot_alias -> alias : build_alias('$1'). +dot_alias -> matched_expr dot_op alias : build_dot_alias('$2', '$1', '$3'). +dot_alias -> matched_expr dot_op open_curly '}' : build_dot_container('$2', '$1', [], []). +dot_alias -> matched_expr dot_op open_curly container_args close_curly : build_dot_container('$2', '$1', '$4', newlines_pair('$3', '$5')). + +dot_op_identifier -> op_identifier : '$1'. +dot_op_identifier -> matched_expr dot_op op_identifier : build_dot('$2', '$1', '$3'). + +dot_do_identifier -> do_identifier : '$1'. +dot_do_identifier -> matched_expr dot_op do_identifier : build_dot('$2', '$1', '$3'). + +dot_bracket_identifier -> bracket_identifier : '$1'. +dot_bracket_identifier -> matched_expr dot_op bracket_identifier : build_dot('$2', '$1', '$3'). + +dot_paren_identifier -> paren_identifier : '$1'. +dot_paren_identifier -> matched_expr dot_op paren_identifier : build_dot('$2', '$1', '$3'). + +dot_call_identifier -> dot_paren_identifier : '$1'. +dot_call_identifier -> matched_expr dot_call_op : {'.', meta_from_token('$2'), ['$1']}. % Fun/local calls + +% Function calls with no parentheses + +call_args_no_parens_expr -> matched_expr : '$1'. +call_args_no_parens_expr -> no_parens_expr : error_no_parens_many_strict('$1'). + +call_args_no_parens_comma_expr -> matched_expr ',' call_args_no_parens_expr : ['$3', '$1']. +call_args_no_parens_comma_expr -> call_args_no_parens_comma_expr ',' call_args_no_parens_expr : ['$3' | '$1']. + +call_args_no_parens_all -> call_args_no_parens_one : '$1'. +call_args_no_parens_all -> call_args_no_parens_ambig : '$1'. +call_args_no_parens_all -> call_args_no_parens_many : '$1'. + +call_args_no_parens_one -> call_args_no_parens_kw : ['$1']. +call_args_no_parens_one -> matched_expr : ['$1']. + +%% This is the only no parens ambiguity where we don't +%% raise nor warn: "parent_call nested_call 1, 2, 3" +%% always assumes that all arguments are nested. +call_args_no_parens_ambig -> no_parens_expr : ['$1']. + +call_args_no_parens_many -> matched_expr ',' call_args_no_parens_kw : ['$1', '$3']. +call_args_no_parens_many -> call_args_no_parens_comma_expr : reverse('$1'). +call_args_no_parens_many -> call_args_no_parens_comma_expr ',' call_args_no_parens_kw : reverse(['$3' | '$1']). + +call_args_no_parens_many_strict -> call_args_no_parens_many : '$1'. +call_args_no_parens_many_strict -> open_paren call_args_no_parens_kw close_paren : error_no_parens_strict('$1'). +call_args_no_parens_many_strict -> open_paren call_args_no_parens_many close_paren : error_no_parens_strict('$1'). + +stab_parens_many -> open_paren call_args_no_parens_kw close_paren : ['$2']. +stab_parens_many -> open_paren call_args_no_parens_many close_paren : '$2'. + +% Containers + +container_expr -> matched_expr : '$1'. +container_expr -> unmatched_expr : '$1'. +container_expr -> no_parens_expr : error_no_parens_container_strict('$1'). + +container_args_base -> container_expr : ['$1']. +container_args_base -> container_args_base ',' container_expr : ['$3' | '$1']. + +container_args -> container_args_base : reverse('$1'). +container_args -> container_args_base ',' : reverse('$1'). +container_args -> container_args_base ',' kw_data : reverse(['$3' | '$1']). + +% Function calls with parentheses + +call_args_parens_expr -> matched_expr : '$1'. +call_args_parens_expr -> unmatched_expr : '$1'. +call_args_parens_expr -> no_parens_expr : error_no_parens_many_strict('$1'). + +call_args_parens_base -> call_args_parens_expr : ['$1']. +call_args_parens_base -> call_args_parens_base ',' call_args_parens_expr : ['$3' | '$1']. + +call_args_parens -> open_paren ')' : + {newlines_pair('$1', '$2'), []}. +call_args_parens -> open_paren no_parens_expr close_paren : + {newlines_pair('$1', '$3'), ['$2']}. +call_args_parens -> open_paren kw_call close_paren : + {newlines_pair('$1', '$3'), ['$2']}. +call_args_parens -> open_paren call_args_parens_base close_paren : + {newlines_pair('$1', '$3'), reverse('$2')}. +call_args_parens -> open_paren call_args_parens_base ',' kw_call close_paren : + {newlines_pair('$1', '$5'), reverse(['$4' | '$2'])}. + +% KV + +kw_eol -> kw_identifier : handle_literal(?exprs('$1'), '$1', [{format, keyword}]). +kw_eol -> kw_identifier eol : handle_literal(?exprs('$1'), '$1', [{format, keyword}]). +kw_eol -> kw_identifier_safe : build_quoted_atom('$1', true, [{format, keyword}]). +kw_eol -> kw_identifier_safe eol : build_quoted_atom('$1', true, [{format, keyword}]). +kw_eol -> kw_identifier_unsafe : build_quoted_atom('$1', false, [{format, keyword}]). +kw_eol -> kw_identifier_unsafe eol : build_quoted_atom('$1', false, [{format, keyword}]). + +kw_base -> kw_eol container_expr : [{'$1', '$2'}]. +kw_base -> kw_base ',' kw_eol container_expr : [{'$3', '$4'} | '$1']. + +kw_call -> kw_base : reverse('$1'). +kw_call -> kw_base ',' : warn_trailing_comma('$2'), reverse('$1'). +kw_call -> kw_base ',' matched_expr : maybe_bad_keyword_call_follow_up('$2', '$1', '$3'). + +kw_data -> kw_base : reverse('$1'). +kw_data -> kw_base ',' : reverse('$1'). +kw_data -> kw_base ',' matched_expr : maybe_bad_keyword_data_follow_up('$2', '$1', '$3'). + +call_args_no_parens_kw_expr -> kw_eol matched_expr : {'$1', '$2'}. +call_args_no_parens_kw_expr -> kw_eol no_parens_expr : warn_nested_no_parens_keyword('$1', '$2'), {'$1', '$2'}. + +call_args_no_parens_kw -> call_args_no_parens_kw_expr : ['$1']. +call_args_no_parens_kw -> call_args_no_parens_kw_expr ',' call_args_no_parens_kw : ['$1' | '$3']. +call_args_no_parens_kw -> call_args_no_parens_kw_expr ',' matched_expr : maybe_bad_keyword_call_follow_up('$2', ['$1'], '$3'). + +% Lists + +list_args -> kw_data : '$1'. +list_args -> container_args_base : reverse('$1'). +list_args -> container_args_base ',' : reverse('$1'). +list_args -> container_args_base ',' kw_data : reverse('$1', '$3'). + +list -> open_bracket ']' : build_list('$1', [], '$2'). +list -> open_bracket list_args close_bracket : build_list('$1', '$2', '$3'). + +% Tuple + +tuple -> open_curly '}' : build_tuple('$1', [], '$2'). +tuple -> open_curly kw_data '}' : bad_keyword('$1', tuple). +tuple -> open_curly container_args close_curly : build_tuple('$1', '$2', '$3'). + +% Bitstrings + +bitstring -> open_bit '>>' : build_bit('$1', [], '$2'). +bitstring -> open_bit kw_data '>>' : bad_keyword('$1', bitstring). +bitstring -> open_bit container_args close_bit : build_bit('$1', '$2', '$3'). + +% Map and structs + +map_base_expr -> sub_matched_expr : '$1'. +map_base_expr -> at_op_eol map_base_expr : build_unary_op('$1', '$2'). +map_base_expr -> unary_op_eol map_base_expr : build_unary_op('$1', '$2'). +map_base_expr -> ellipsis_op map_base_expr : build_unary_op('$1', '$2'). + +assoc_op_eol -> assoc_op : '$1'. +assoc_op_eol -> assoc_op eol : '$1'. + +assoc_expr -> matched_expr assoc_op_eol matched_expr : {'$1', '$3'}. +assoc_expr -> unmatched_expr assoc_op_eol unmatched_expr : {'$1', '$3'}. +assoc_expr -> matched_expr assoc_op_eol unmatched_expr : {'$1', '$3'}. +assoc_expr -> unmatched_expr assoc_op_eol matched_expr : {'$1', '$3'}. +assoc_expr -> map_base_expr : '$1'. + +assoc_update -> matched_expr pipe_op_eol assoc_expr : {'$2', '$1', ['$3']}. +assoc_update -> unmatched_expr pipe_op_eol assoc_expr : {'$2', '$1', ['$3']}. + +assoc_update_kw -> matched_expr pipe_op_eol kw_data : {'$2', '$1', '$3'}. +assoc_update_kw -> unmatched_expr pipe_op_eol kw_data : {'$2', '$1', '$3'}. + +assoc_base -> assoc_expr : ['$1']. +assoc_base -> assoc_base ',' assoc_expr : ['$3' | '$1']. + +assoc -> assoc_base : reverse('$1'). +assoc -> assoc_base ',' : reverse('$1'). + +map_op -> '%{}' : '$1'. +map_op -> '%{}' eol : '$1'. + +map_close -> kw_data close_curly : {'$1', '$2'}. +map_close -> assoc close_curly : {'$1', '$2'}. +map_close -> assoc_base ',' kw_data close_curly : {reverse('$1', '$3'), '$4'}. + +map_args -> open_curly '}' : build_map('$1', [], '$2'). +map_args -> open_curly map_close : build_map('$1', element(1, '$2'), element(2, '$2')). +map_args -> open_curly assoc_update close_curly : build_map_update('$1', '$2', '$3', []). +map_args -> open_curly assoc_update ',' close_curly : build_map_update('$1', '$2', '$4', []). +map_args -> open_curly assoc_update ',' map_close : build_map_update('$1', '$2', element(2, '$4'), element(1, '$4')). +map_args -> open_curly assoc_update_kw close_curly : build_map_update('$1', '$2', '$3', []). + +map -> map_op map_args : adjust_map_column('$2'). +map -> '%' map_base_expr map_args : {'%', meta_from_token('$1'), ['$2', '$3']}. +map -> '%' map_base_expr eol map_args : {'%', meta_from_token('$1'), ['$2', '$4']}. + +Erlang code. + +-define(columns(), get(elixir_parser_columns)). +-define(token_metadata(), get(elixir_token_metadata)). + +-define(id(Token), element(1, Token)). +-define(location(Token), element(2, Token)). +-define(exprs(Token), element(3, Token)). +-define(meta(Node), element(2, Node)). +-define(rearrange_uop(Op), (Op == 'not' orelse Op == '!')). + +-compile({inline, meta_from_token/1, meta_from_location/1, is_eol/1}). +-import(lists, [reverse/1, reverse/2]). + +meta_from_token(Token) -> + meta_from_location(?location(Token)). + +meta_from_location({Line, Column, _}) -> + case ?columns() of + true -> [{line, Line}, {column, Column}]; + false -> [{line, Line}] + end. + +do_end_meta(Do, End) -> + case ?token_metadata() of + true -> + [{do, meta_from_location(?location(Do))}, {'end', meta_from_location(?location(End))}]; + false -> + [] + end. + +meta_from_token_with_closing(Begin, End) -> + case ?token_metadata() of + true -> + [{closing, meta_from_location(?location(End))} | meta_from_token(Begin)]; + false -> + meta_from_token(Begin) + end. + +append_non_empty(Left, []) -> Left; +append_non_empty(Left, Right) -> Left ++ Right. + +%% Handle metadata in literals + +handle_literal(Literal, Token) -> + handle_literal(Literal, Token, []). + +handle_literal(Literal, Token, ExtraMeta) -> + case get(elixir_literal_encoder) of + false -> + Literal; + + Fun -> + Meta = ExtraMeta ++ meta_from_token(Token), + case Fun(Literal, Meta) of + {ok, EncodedLiteral} -> + EncodedLiteral; + {error, Reason} -> + return_error(?location(Token), elixir_utils:characters_to_list(Reason) ++ [": "], "literal") + end + end. + +handle_number(Number, Token, Original) -> + case ?token_metadata() of + true -> handle_literal(Number, Token, [{token, elixir_utils:characters_to_binary(Original)}]); + false -> handle_literal(Number, Token, []) + end. + +number_value({_, {_, _, Value}, _}) -> + Value. + +%% Operators + +build_op(Left, {Op, Right}) -> + build_op(Left, Op, Right). + +build_op(AST, {_Kind, Location, '//'}, Right) -> + case AST of + {'..', Meta, [Left, Middle]} -> + {'..//', Meta, [Left, Middle, Right]}; + + _ -> + return_error(Location, "the range step operator (//) must immediately follow the range definition operator (..), for example: 1..9//2. If you wanted to define a default argument, use (\\\\) instead. Syntax error before: ", "'//'") + end; + +build_op({UOp, _, [Left]}, {_Kind, {Line, Column, _} = Location, 'in'}, Right) when ?rearrange_uop(UOp) -> + %% TODO: Remove "not left in right" rearrangement on v2.0 + warn({Line, Column}, "\"not expr1 in expr2\" is deprecated, use \"expr1 not in expr2\" instead"), + Meta = meta_from_location(Location), + {UOp, Meta, [{'in', Meta, [Left, Right]}]}; + +build_op(Left, {_Kind, Location, 'not in'}, Right) -> + Meta = meta_from_location(Location), + {'not', Meta, [{'in', Meta, [Left, Right]}]}; + +build_op(Left, {_Kind, Location, Op}, Right) -> + {Op, newlines_op(Location) ++ meta_from_location(Location), [Left, Right]}. + +build_unary_op({_Kind, {Line, Column, _}, '//'}, Expr) -> + {Outer, Inner} = + case ?columns() of + true -> {[{column, Column+1}], [{column, Column}]}; + false -> {[], []} + end, + {'/', [{line, Line} | Outer], [{'/', [{line, Line} | Inner], nil}, Expr]}; + +build_unary_op({_Kind, Location, Op}, Expr) -> + {Op, meta_from_location(Location), [Expr]}. + +build_nullary_op({_Kind, Location, Op}) -> + {Op, meta_from_location(Location), []}. + +build_list(Left, Args, Right) -> + {handle_literal(Args, Left, newlines_pair(Left, Right)), ?location(Left)}. + +build_tuple(Left, [Arg1, Arg2], Right) -> + handle_literal({Arg1, Arg2}, Left, newlines_pair(Left, Right)); +build_tuple(Left, Args, Right) -> + {'{}', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}. + +build_bit(Left, Args, Right) -> + {'<<>>', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}. + +build_map(Left, Args, Right) -> + {'%{}', newlines_pair(Left, Right) ++ meta_from_token(Left), Args}. + +build_map_update(Left, {Pipe, Struct, Map}, Right, Extra) -> + Op = build_op(Struct, Pipe, append_non_empty(Map, Extra)), + {'%{}', newlines_pair(Left, Right) ++ meta_from_token(Left), [Op]}. + +adjust_map_column(Map) -> + case ?columns() of + true -> + {'%{}', Meta, Pairs} = Map, + UpdatedMeta = [{Key, if Key =:= column -> Value - 1; true -> Value end} || + {Key, Value} <- Meta], + {'%{}', UpdatedMeta, Pairs}; + false -> + Map + end. + +%% Blocks + +build_block(Exprs) -> build_block(Exprs, []). + +build_block([{unquote_splicing, _, [_]}]=Exprs, Meta) -> + {'__block__', Meta, Exprs}; +build_block([Expr], _Meta) -> + Expr; +build_block(Exprs, Meta) -> + {'__block__', Meta, Exprs}. + +%% Newlines + +newlines_pair(Left, Right) -> + case ?token_metadata() of + true -> + newlines(?location(Left), [{closing, meta_from_location(?location(Right))}]); + false -> + [] + end. + +newlines_op(Location) -> + case ?token_metadata() of + true -> newlines(Location, []); + false -> [] + end. + +next_is_eol(Token, {_, {_, _, Count}}) -> + {Line, Column, _} = ?location(Token), + setelement(2, Token, {Line, Column, Count}). + +newlines({_, _, Count}, Meta) when is_integer(Count) and (Count > 0) -> + [{newlines, Count} | Meta]; +newlines(_, Meta) -> + Meta. + +annotate_eoe(Token, Stack) -> + case ?token_metadata() of + true -> + case {Token, Stack} of + {{_, Location}, [{'->', StabMeta, [StabArgs, {Left, Meta, Right}]} | Rest]} when is_list(Meta) -> + [{'->', StabMeta, [StabArgs, {Left, [{end_of_expression, end_of_expression(Location)} | Meta], Right}]} | Rest]; + + {{_, Location}, [{Left, Meta, Right} | Rest]} when is_list(Meta), Left =/= '->' -> + [{Left, [{end_of_expression, end_of_expression(Location)} | Meta], Right} | Rest]; + + _ -> + Stack + end; + false -> + Stack + end. + +end_of_expression({_, _, Count} = Location) when is_integer(Count) -> + [{newlines, Count} | meta_from_location(Location)]; +end_of_expression(Location) -> + meta_from_location(Location). + +%% Dots + +build_alias({'alias', Location, Alias}) -> + Meta = meta_from_location(Location), + MetaWithExtra = + case ?token_metadata() of + true -> [{last, meta_from_location(Location)} | Meta]; + false -> Meta + end, + {'__aliases__', MetaWithExtra, [Alias]}. + +build_dot_alias(_Dot, {'__aliases__', Meta, Left}, {'alias', SegmentLocation, Right}) -> + MetaWithExtra = + case ?token_metadata() of + true -> lists:keystore(last, 1, Meta, {last, meta_from_location(SegmentLocation)}); + false -> Meta + end, + {'__aliases__', MetaWithExtra, Left ++ [Right]}; +build_dot_alias(_Dot, Atom, Right) when is_atom(Atom) -> + error_bad_atom(Right); +build_dot_alias(Dot, Expr, {'alias', SegmentLocation, Right}) -> + Meta = meta_from_token(Dot), + MetaWithExtra = + case ?token_metadata() of + true -> [{last, meta_from_location(SegmentLocation)} | Meta]; + false -> Meta + end, + {'__aliases__', MetaWithExtra, [Expr, Right]}. + +build_dot_container(Dot, Left, Right, Extra) -> + Meta = meta_from_token(Dot), + {{'.', Meta, [Left, '{}']}, Extra ++ Meta, Right}. + +build_dot(Dot, Left, {_, Location, _} = Right) -> + Meta = meta_from_token(Dot), + IdentifierLocation = meta_from_location(Location), + {'.', Meta, IdentifierLocation, [Left, extract_identifier(Right)]}. + +extract_identifier({Kind, _, Identifier}) when + Kind == identifier; Kind == bracket_identifier; Kind == paren_identifier; + Kind == do_identifier; Kind == op_identifier -> + Identifier. + +%% Identifiers + +build_nested_parens(Dot, Args1, {Args2Meta, Args2}, {BlockMeta, Block}) -> + Identifier = build_parens(Dot, Args1, {[], []}), + Meta = BlockMeta ++ Args2Meta ++ ?meta(Identifier), + {Identifier, Meta, append_non_empty(Args2, Block)}. + +build_parens(Expr, {ArgsMeta, Args}, {BlockMeta, Block}) -> + {BuiltExpr, BuiltMeta, BuiltArgs} = build_call(Expr, append_non_empty(Args, Block)), + {BuiltExpr, BlockMeta ++ ArgsMeta ++ BuiltMeta, BuiltArgs}. + +build_no_parens_do_block(Expr, Args, {BlockMeta, Block}) -> + {BuiltExpr, BuiltMeta, BuiltArgs} = build_call(Expr, Args ++ Block), + {BuiltExpr, BlockMeta ++ BuiltMeta, BuiltArgs}. + +build_no_parens(Expr, Args) -> + build_call(Expr, Args). + +build_identifier({'.', Meta, IdentifierLocation, DotArgs}) -> + {{'.', Meta, DotArgs}, [{no_parens, true} | IdentifierLocation], []}; + +build_identifier({'.', Meta, _} = Dot) -> + {Dot, [{no_parens, true} | Meta], []}; + +build_identifier({_, Location, Identifier}) -> + {Identifier, meta_from_location(Location), nil}. + +build_call({'.', Meta, IdentifierLocation, DotArgs}, Args) -> + {{'.', Meta, DotArgs}, IdentifierLocation, Args}; + +build_call({'.', Meta, _} = Dot, Args) -> + {Dot, Meta, Args}; + +build_call({op_identifier, Location, Identifier}, [Arg]) -> + {Identifier, [{ambiguous_op, nil} | meta_from_location(Location)], [Arg]}; + +build_call({_, Location, Identifier}, Args) -> + {Identifier, meta_from_location(Location), Args}. + +%% Fn + +build_fn(Fn, Stab, End) -> + case check_stab(Stab, none) of + stab -> + Meta = newlines_op(?location(Fn)) ++ meta_from_token_with_closing(Fn, End), + {fn, Meta, collect_stab(Stab, [], [])}; + block -> + return_error(?location(Fn), "expected anonymous functions to be defined with -> inside: ", "'fn'") + end. + +%% Access + +build_access_arg(Left, Args, Right) -> + {Args, newlines_pair(Left, Right) ++ meta_from_token(Left)}. + +build_access(Expr, {List, Meta}) -> + {{'.', Meta, ['Elixir.Access', get]}, Meta, [Expr, List]}. + +%% Interpolation aware + +build_sigil({sigil, Location, Atom, Parts, Modifiers, Indentation, Delimiter}) -> + Meta = meta_from_location(Location), + MetaWithDelimiter = [{delimiter, Delimiter} | Meta], + MetaWithIndentation = meta_with_indentation(Meta, Indentation), + {Atom, + MetaWithDelimiter, + [{'<<>>', MetaWithIndentation, string_parts(Parts)}, Modifiers]}. + +meta_with_indentation(Meta, nil) -> + Meta; +meta_with_indentation(Meta, Indentation) -> + [{indentation, Indentation} | Meta]. + +meta_with_from_brackets({List, Meta}) -> + {List, [{from_brackets, true} | Meta]}. + +build_bin_heredoc({bin_heredoc, Location, Indentation, Args}) -> + ExtraMeta = + case ?token_metadata() of + true -> [{delimiter, <<$", $", $">>}, {indentation, Indentation}]; + false -> [] + end, + build_bin_string({bin_string, Location, Args}, ExtraMeta). + +build_list_heredoc({list_heredoc, Location, Indentation, Args}) -> + ExtraMeta = + case ?token_metadata() of + true -> [{delimiter, <<$', $', $'>>}, {indentation, Indentation}]; + false -> [] + end, + build_list_string({list_string, Location, Args}, ExtraMeta). + +build_bin_string({bin_string, _Location, [H]} = Token, ExtraMeta) when is_binary(H) -> + handle_literal(H, Token, ExtraMeta); +build_bin_string({bin_string, Location, Args}, ExtraMeta) -> + Meta = + case ?token_metadata() of + true -> ExtraMeta ++ meta_from_location(Location); + false -> meta_from_location(Location) + end, + {'<<>>', Meta, string_parts(Args)}. + +build_list_string({list_string, _Location, [H]} = Token, ExtraMeta) when is_binary(H) -> + handle_literal(elixir_utils:characters_to_list(H), Token, ExtraMeta); +build_list_string({list_string, Location, Args}, ExtraMeta) -> + Meta = meta_from_location(Location), + MetaWithExtra = + case ?token_metadata() of + true -> ExtraMeta ++ Meta; + false -> Meta + end, + {{'.', Meta, ['Elixir.List', to_charlist]}, MetaWithExtra, [charlist_parts(Args)]}. + +build_quoted_atom({_, _Location, [H]} = Token, Safe, ExtraMeta) when is_binary(H) -> + Op = binary_to_atom_op(Safe), + handle_literal(erlang:Op(H, utf8), Token, ExtraMeta); +build_quoted_atom({_, Location, Args}, Safe, ExtraMeta) -> + Meta = meta_from_location(Location), + MetaWithExtra = + case ?token_metadata() of + true -> ExtraMeta ++ Meta; + false -> Meta + end, + {{'.', Meta, [erlang, binary_to_atom_op(Safe)]}, MetaWithExtra, [{'<<>>', Meta, string_parts(Args)}, utf8]}. + +binary_to_atom_op(true) -> binary_to_existing_atom; +binary_to_atom_op(false) -> binary_to_atom. + +charlist_parts(Parts) -> + [charlist_part(Part) || Part <- Parts]. +charlist_part(Binary) when is_binary(Binary) -> + Binary; +charlist_part({Begin, End, Tokens}) -> + Form = string_tokens_parse(Tokens), + Meta = meta_from_location(Begin), + MetaWithExtra = + case ?token_metadata() of + true -> [{closing, meta_from_location(End)} | Meta]; + false -> Meta + end, + {{'.', Meta, ['Elixir.Kernel', to_string]}, [{from_interpolation, true} | MetaWithExtra], [Form]}. + +string_parts(Parts) -> + [string_part(Part) || Part <- Parts]. +string_part(Binary) when is_binary(Binary) -> + Binary; +string_part({Begin, End, Tokens}) -> + Form = string_tokens_parse(Tokens), + Meta = meta_from_location(Begin), + MetaWithExtra = + case ?token_metadata() of + true -> [{closing, meta_from_location(End)} | Meta]; + false -> Meta + end, + {'::', Meta, [{{'.', Meta, ['Elixir.Kernel', to_string]}, [{from_interpolation, true} | MetaWithExtra], [Form]}, {binary, Meta, nil}]}. + +string_tokens_parse(Tokens) -> + case parse(Tokens) of + {ok, Forms} -> Forms; + {error, _} = Error -> throw(Error) + end. + +delimiter(Delimiter) -> + case ?token_metadata() of + true -> [{delimiter, Delimiter}]; + false -> [] + end. + +%% Keywords + +check_stab([{'->', _, [_, _]}], _) -> stab; +check_stab([], none) -> block; +check_stab([_], none) -> block; +check_stab([_], Meta) -> error_invalid_stab(Meta); +check_stab([{'->', Meta, [_, _]} | T], _) -> check_stab(T, Meta); +check_stab([_ | T], MaybeMeta) -> check_stab(T, MaybeMeta). + +build_stab(Stab) -> + case check_stab(Stab, none) of + block -> build_block(reverse(Stab)); + stab -> collect_stab(Stab, [], []) + end. + +build_paren_stab(_Before, [{Op, _, [_]}]=Exprs, _After) when ?rearrange_uop(Op) -> + {'__block__', [], Exprs}; +build_paren_stab(Before, Stab, After) -> + case check_stab(Stab, none) of + block -> build_block(reverse(Stab), meta_from_token_with_closing(Before, After)); + stab -> handle_literal(collect_stab(Stab, [], []), Before, newlines_pair(Before, After)) + end. + +collect_stab([{'->', Meta, [Left, Right]} | T], Exprs, Stabs) -> + Stab = {'->', Meta, [Left, build_block([Right | Exprs])]}, + collect_stab(T, [], [Stab | Stabs]); + +collect_stab([H | T], Exprs, Stabs) -> + collect_stab(T, [H | Exprs], Stabs); + +collect_stab([], [], Stabs) -> + Stabs. + +%% Every time the parser sees a (unquote_splicing()) +%% it assumes that a block is being spliced, wrapping +%% the splicing in a __block__. But in the stab clause, +%% we can have (unquote_splicing(1, 2, 3)) -> :ok, in such +%% case, we don't actually want the block, since it is +%% an arg style call. unwrap_splice unwraps the splice +%% from such blocks. +unwrap_splice([{'__block__', _, [{unquote_splicing, _, _}] = Splice}]) -> + Splice; +unwrap_splice(Other) -> + Other. + +unwrap_when(Args) -> + case elixir_utils:split_last(Args) of + {Start, {'when', Meta, [_, _] = End}} -> + [{'when', Meta, Start ++ End}]; + {_, _} -> + Args + end. + +%% Warnings and errors + +return_error({Line, Column, _}, ErrorMessage, ErrorToken) -> + return_error([{line, Line}, {column, Column}], [ErrorMessage, ErrorToken]). + +%% We should prefer to use return_error as it includes +%% Line and Column but that's not always possible. +return_error_with_meta(Meta, ErrorMessage, ErrorToken) -> + return_error(Meta, [ErrorMessage, ErrorToken]). + +error_invalid_stab(MetaStab) -> + return_error_with_meta(MetaStab, + "unexpected operator ->. If you want to define multiple clauses, the first expression must use ->. " + "Syntax error before: ", "'->'"). + +error_bad_atom(Token) -> + return_error(?location(Token), "atom cannot be followed by an alias. " + "If the '.' was meant to be part of the atom's name, " + "the atom name must be quoted. Syntax error before: ", "'.'"). + +bad_keyword(Token, Context) -> + return_error(?location(Token), + "unexpected keyword list inside " ++ atom_to_list(Context) ++ ". " + "Did you mean to write a map (using %{...}) or a list (using [...]) instead? " + "Syntax error after: ", "'{'"). + +maybe_bad_keyword_call_follow_up(_Token, KW, {'__cursor__', _, []} = Expr) -> + reverse([Expr | KW]); +maybe_bad_keyword_call_follow_up(Token, _KW, _Expr) -> + return_error(?location(Token), + "unexpected expression after keyword list. Keyword lists must always come as the last argument. Therefore, this is not allowed:\n\n" + " function_call(1, some: :option, 2)\n\n" + "Instead, wrap the keyword in brackets:\n\n" + " function_call(1, [some: :option], 2)\n\n" + "Syntax error after: ", "','"). + +maybe_bad_keyword_data_follow_up(_Token, KW, {'__cursor__', _, []} = Expr) -> + reverse([Expr | KW]); +maybe_bad_keyword_data_follow_up(Token, _KW, _Expr) -> + return_error(?location(Token), + "unexpected expression after keyword list. Keyword lists must always come last in lists and maps. Therefore, this is not allowed:\n\n" + " [some: :value, :another]\n" + " %{some: :value, another => value}\n\n" + "Instead, reorder it to be the last entry:\n\n" + " [:another, some: :value]\n" + " %{another => value, some: :value}\n\n" + "Syntax error after: ", "','"). + +error_no_parens_strict(Token) -> + return_error(?location(Token), "unexpected parentheses. If you are making a " + "function call, do not insert spaces between the function name and the " + "opening parentheses. Syntax error before: ", "'('"). + +error_no_parens_many_strict(Node) -> + return_error_with_meta(?meta(Node), + "unexpected comma. Parentheses are required to solve ambiguity in nested calls.\n\n" + "This error happens when you have nested function calls without parentheses. " + "For example:\n\n" + " parent_call a, nested_call b, c, d\n\n" + "In the example above, we don't know if the parameters \"c\" and \"d\" apply " + "to the function \"parent_call\" or \"nested_call\". You can solve this by " + "explicitly adding parentheses:\n\n" + " parent_call a, nested_call(b, c, d)\n\n" + "Or by adding commas (in case a nested call is not intended):\n\n" + " parent_call a, nested_call, b, c, d\n\n" + "Elixir cannot compile otherwise. Syntax error before: ", "','"). + +error_no_parens_container_strict(Node) -> + return_error_with_meta(?meta(Node), + "unexpected comma. Parentheses are required to solve ambiguity inside containers.\n\n" + "This error may happen when you forget a comma in a list or other container:\n\n" + " [a, b c, d]\n\n" + "Or when you have ambiguous calls:\n\n" + " [function a, b, c]\n\n" + "In the example above, we don't know if the values \"b\" and \"c\" " + "belongs to the list or the function \"function\". You can solve this by explicitly " + "adding parentheses:\n\n" + " [one, function(a, b, c)]\n\n" + "Elixir cannot compile otherwise. Syntax error before: ", "','"). + +error_too_many_access_syntax(Comma) -> + return_error(?location(Comma), "too many arguments when accessing a value. " + "The value[key] notation in Elixir expects either a single argument or a keyword list. " + "The following examples are allowed:\n\n" + " value[one]\n" + " value[one: 1, two: 2]\n" + " value[[one, two, three]]\n\n" + "These are invalid:\n\n" + " value[1, 2, 3]\n" + " value[one, two, three]\n\n" + "Syntax error after: ", "','"). + +error_invalid_kw_identifier({_, Location, do}) -> + return_error(Location, elixir_tokenizer:invalid_do_error("unexpected keyword: "), "do:"); +error_invalid_kw_identifier({_, Location, KW}) -> + return_error(Location, "syntax error before: ", "'" ++ atom_to_list(KW) ++ ":'"). + +%% TODO: Make this an error on v2.0 +warn_trailing_comma({',', {Line, Column, _}}) -> + warn({Line, Column}, "trailing commas are not allowed inside function/macro call arguments"). + +%% TODO: Make this an error on v2.0 +warn_pipe({arrow_op, {Line, Column, _}, Op}, {_, [_ | _], [_ | _]}) -> + warn( + {Line, Column}, + io_lib:format( + "parentheses are required when piping into a function call. For example:\n\n" + " foo 1 ~ts bar 2 ~ts baz 3\n\n" + "is ambiguous and should be written as\n\n" + " foo(1) ~ts bar(2) ~ts baz(3)\n\n" + "Ambiguous pipe found at:", + [Op, Op, Op, Op] + ) + ); +warn_pipe(_Token, _) -> + ok. + +%% TODO: Make this an error on v2.0 +warn_no_parens_after_do_op({{_Type, Location, Op}, _}) -> + {Line, _, _} = Location, + + warn( + Line, + "missing parentheses on expression following operator \"" ++ atom_to_list(Op) ++ "\", " + "you must add parentheses to avoid ambiguities" + ). + +%% TODO: Make this an error on v2.0 +warn_nested_no_parens_keyword(Key, Value) when is_atom(Key) -> + {line, Line} = lists:keyfind(line, 1, ?meta(Value)), + warn( + Line, + "missing parentheses for expression following \"" ++ atom_to_list(Key) ++ ":\" keyword. " + "Parentheses are required to solve ambiguity inside keywords.\n\n" + "This error happens when you have function calls without parentheses inside keywords. " + "For example:\n\n" + " function(arg, one: nested_call a, b, c)\n" + " function(arg, one: if expr, do: :this, else: :that)\n\n" + "In the examples above, we don't know if the arguments \"b\" and \"c\" apply " + "to the function \"function\" or \"nested_call\". Or if the keywords \"do\" and " + "\"else\" apply to the function \"function\" or \"if\". You can solve this by " + "explicitly adding parentheses:\n\n" + " function(arg, one: if(expr, do: :this, else: :that))\n" + " function(arg, one: nested_call(a, b, c))\n\n" + "Ambiguity found at:" + ); + +% Key might not be an atom when using literal_encoder, we just skip the warning +warn_nested_no_parens_keyword(_Key, _Value) -> + ok. + +warn_empty_paren({_, {Line, Column, _}}) -> + warn( + {Line, Column}, + "invalid expression (). " + "If you want to invoke or define a function, make sure there are " + "no spaces between the function name and its arguments. If you wanted " + "to pass an empty block or code, pass a value instead, such as a nil or an atom" + ). + +warn_empty_stab_clause({stab_op, {Line, Column, _}, '->'}) -> + warn( + {Line, Column}, + "an expression is always required on the right side of ->. " + "Please provide a value after ->" + ). + +warn(LineColumn, Message) -> + case get(elixir_parser_warning_file) of + nil -> ok; + File -> future_elixir_errors:erl_warn(LineColumn, File, Message) + end. diff --git a/forge/src/future_elixir_tokenizer.erl b/forge/src/future_elixir_tokenizer.erl new file mode 100644 index 00000000..0ace9a69 --- /dev/null +++ b/forge/src/future_elixir_tokenizer.erl @@ -0,0 +1,1827 @@ +%% Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/src/elixir_tokenizer.erl +%% I changed module name and includes +-module(future_elixir_tokenizer). +-include("future_elixir.hrl"). +-include("future_elixir_tokenizer.hrl"). +-export([tokenize/1, tokenize/3, tokenize/4, invalid_do_error/1, terminator/1]). + +-define(at_op(T), + T =:= $@). + +-define(capture_op(T), + T =:= $&). + +-define(unary_op(T), + T =:= $!; + T =:= $^). + +-define(range_op(T1, T2), + T1 =:= $., T2 =:= $.). + +-define(concat_op(T1, T2), + T1 =:= $+, T2 =:= $+; + T1 =:= $-, T2 =:= $-; + T1 =:= $<, T2 =:= $>). + +-define(concat_op3(T1, T2, T3), + T1 =:= $+, T2 =:= $+, T3 =:= $+; + T1 =:= $-, T2 =:= $-, T3 =:= $-). + +-define(power_op(T1, T2), + T1 =:= $*, T2 =:= $*). + +-define(mult_op(T), + T =:= $* orelse T =:= $/). + +-define(dual_op(T), + T =:= $+ orelse T =:= $-). + +-define(arrow_op3(T1, T2, T3), + T1 =:= $<, T2 =:= $<, T3 =:= $<; + T1 =:= $>, T2 =:= $>, T3 =:= $>; + T1 =:= $~, T2 =:= $>, T3 =:= $>; + T1 =:= $<, T2 =:= $<, T3 =:= $~; + T1 =:= $<, T2 =:= $~, T3 =:= $>; + T1 =:= $<, T2 =:= $|, T3 =:= $>). + +-define(arrow_op(T1, T2), + T1 =:= $|, T2 =:= $>; + T1 =:= $~, T2 =:= $>; + T1 =:= $<, T2 =:= $~). + +-define(rel_op(T), + T =:= $<; + T =:= $>). + +-define(rel_op2(T1, T2), + T1 =:= $<, T2 =:= $=; + T1 =:= $>, T2 =:= $=). + +-define(comp_op2(T1, T2), + T1 =:= $=, T2 =:= $=; + T1 =:= $=, T2 =:= $~; + T1 =:= $!, T2 =:= $=). + +-define(comp_op3(T1, T2, T3), + T1 =:= $=, T2 =:= $=, T3 =:= $=; + T1 =:= $!, T2 =:= $=, T3 =:= $=). + +-define(ternary_op(T1, T2), + T1 =:= $/, T2 =:= $/). + +-define(and_op(T1, T2), + T1 =:= $&, T2 =:= $&). + +-define(or_op(T1, T2), + T1 =:= $|, T2 =:= $|). + +-define(and_op3(T1, T2, T3), + T1 =:= $&, T2 =:= $&, T3 =:= $&). + +-define(or_op3(T1, T2, T3), + T1 =:= $|, T2 =:= $|, T3 =:= $|). + +-define(match_op(T), + T =:= $=). + +-define(in_match_op(T1, T2), + T1 =:= $<, T2 =:= $-; + T1 =:= $\\, T2 =:= $\\). + +-define(stab_op(T1, T2), + T1 =:= $-, T2 =:= $>). + +-define(type_op(T1, T2), + T1 =:= $:, T2 =:= $:). + +-define(pipe_op(T), + T =:= $|). + +-define(ellipsis_op3(T1, T2, T3), + T1 =:= $., T2 =:= $., T3 =:= $.). + +%% Deprecated operators + +-define(unary_op3(T1, T2, T3), + T1 =:= $~, T2 =:= $~, T3 =:= $~). + +-define(xor_op3(T1, T2, T3), + T1 =:= $^, T2 =:= $^, T3 =:= $^). + +tokenize(String, Line, Column, #elixir_tokenizer{} = Scope) -> + tokenize(String, Line, Column, Scope, []); + +tokenize(String, Line, Column, Opts) -> + IdentifierTokenizer = elixir_config:identifier_tokenizer(), + + Scope = + lists:foldl(fun + ({check_terminators, false}, Acc) -> + Acc#elixir_tokenizer{terminators=none}; + ({cursor_completion, true}, Acc) -> + Acc#elixir_tokenizer{cursor_completion=prune_and_cursor}; + ({existing_atoms_only, ExistingAtomsOnly}, Acc) when is_boolean(ExistingAtomsOnly) -> + Acc#elixir_tokenizer{existing_atoms_only=ExistingAtomsOnly}; + ({static_atoms_encoder, StaticAtomsEncoder}, Acc) when is_function(StaticAtomsEncoder) -> + Acc#elixir_tokenizer{static_atoms_encoder=StaticAtomsEncoder}; + ({preserve_comments, PreserveComments}, Acc) when is_function(PreserveComments) -> + Acc#elixir_tokenizer{preserve_comments=PreserveComments}; + ({unescape, Unescape}, Acc) when is_boolean(Unescape) -> + Acc#elixir_tokenizer{unescape=Unescape}; + (_, Acc) -> + Acc + end, #elixir_tokenizer{identifier_tokenizer=IdentifierTokenizer, column=Column}, Opts), + + tokenize(String, Line, Column, Scope, []). + +tokenize(String, Line, Opts) -> + tokenize(String, Line, 1, Opts). + +tokenize([], Line, Column, #elixir_tokenizer{cursor_completion=Cursor} = Scope, Tokens) when Cursor /= false -> + #elixir_tokenizer{ascii_identifiers_only=Ascii, terminators=Terminators, warnings=Warnings} = Scope, + + {CursorColumn, CursorTerminators, AccTokens} = + add_cursor(Line, Column, Cursor, Terminators, Tokens), + + AllWarnings = maybe_unicode_lint_warnings(Ascii, Tokens, Warnings), + {AccTerminators, _AccColumn} = cursor_complete(Line, CursorColumn, CursorTerminators), + {ok, Line, CursorColumn, AllWarnings, AccTokens, AccTerminators}; + +tokenize([], EndLine, EndColumn, #elixir_tokenizer{terminators=[{Start, {StartLine, StartColumn, _}, _} | _]} = Scope, Tokens) -> + End = terminator(Start), + Hint = missing_terminator_hint(Start, End, Scope), + Message = "missing terminator: ~ts", + Formatted = io_lib:format(Message, [End]), + Meta = [ + {opening_delimiter, Start}, + {expected_delimiter, End}, + {line, StartLine}, + {column, StartColumn}, + {end_line, EndLine}, + {end_column, EndColumn} + ], + error({Meta, [Formatted, Hint], []}, [], Scope, Tokens); + +tokenize([], Line, Column, #elixir_tokenizer{} = Scope, Tokens) -> + #elixir_tokenizer{ascii_identifiers_only=Ascii, warnings=Warnings} = Scope, + AllWarnings = maybe_unicode_lint_warnings(Ascii, Tokens, Warnings), + {ok, Line, Column, AllWarnings, Tokens, []}; + +% VC merge conflict + +tokenize(("<<<<<<<" ++ _) = Original, Line, 1, Scope, Tokens) -> + FirstLine = lists:takewhile(fun(C) -> C =/= $\n andalso C =/= $\r end, Original), + Reason = {?LOC(Line, 1), "found an unexpected version control marker, please resolve the conflicts: ", FirstLine}, + error(Reason, Original, Scope, Tokens); + +% Base integers + +tokenize([$0, $x, H | T], Line, Column, Scope, Tokens) when ?is_hex(H) -> + {Rest, Number, OriginalRepresentation, Length} = tokenize_hex(T, [H], 1), + Token = {int, {Line, Column, Number}, OriginalRepresentation}, + tokenize(Rest, Line, Column + 2 + Length, Scope, [Token | Tokens]); + +tokenize([$0, $b, H | T], Line, Column, Scope, Tokens) when ?is_bin(H) -> + {Rest, Number, OriginalRepresentation, Length} = tokenize_bin(T, [H], 1), + Token = {int, {Line, Column, Number}, OriginalRepresentation}, + tokenize(Rest, Line, Column + 2 + Length, Scope, [Token | Tokens]); + +tokenize([$0, $o, H | T], Line, Column, Scope, Tokens) when ?is_octal(H) -> + {Rest, Number, OriginalRepresentation, Length} = tokenize_octal(T, [H], 1), + Token = {int, {Line, Column, Number}, OriginalRepresentation}, + tokenize(Rest, Line, Column + 2 + Length, Scope, [Token | Tokens]); + +% Comments + +tokenize([$# | String], Line, Column, Scope, Tokens) -> + case tokenize_comment(String, [$#]) of + {error, Char} -> + error_comment(Char, [$# | String], Line, Column, Scope, Tokens); + {Rest, Comment} -> + preserve_comments(Line, Column, Tokens, Comment, Rest, Scope), + tokenize(Rest, Line, Column, Scope, reset_eol(Tokens)) + end; + +% Sigils + +tokenize([$~, H | _T] = Original, Line, Column, Scope, Tokens) when ?is_upcase(H) orelse ?is_downcase(H) -> + tokenize_sigil(Original, Line, Column, Scope, Tokens); + +% Char tokens + +% We tokenize char literals (?a) as {char, _, CharInt} instead of {number, _, +% CharInt}. This is exactly what Erlang does with Erlang char literals +% ($a). This means we'll have to adjust the error message for char literals in +% future_elixir_errors.erl as by default {char, _, _} tokens are "hijacked" by Erlang +% and printed with Erlang syntax ($a) in the parser's error messages. + +tokenize([$?, $\\, H | T], Line, Column, Scope, Tokens) -> + Char = future_elixir_interpolation:unescape_map(H), + + NewScope = if + H =:= Char, H =/= $\\ -> + case handle_char(Char) of + {Escape, Name} -> + Msg = io_lib:format("found ?\\ followed by code point 0x~.16B (~ts), please use ?~ts instead", + [Char, Name, Escape]), + prepend_warning(Line, Column, Msg, Scope); + + false when ?is_downcase(H); ?is_upcase(H) -> + Msg = io_lib:format("unknown escape sequence ?\\~tc, use ?~tc instead", [H, H]), + prepend_warning(Line, Column, Msg, Scope); + + false -> + Scope + end; + true -> + Scope + end, + + Token = {char, {Line, Column, [$?, $\\, H]}, Char}, + tokenize(T, Line, Column + 3, NewScope, [Token | Tokens]); + +tokenize([$?, Char | T], Line, Column, Scope, Tokens) -> + NewScope = case handle_char(Char) of + {Escape, Name} -> + Msg = io_lib:format("found ? followed by code point 0x~.16B (~ts), please use ?~ts instead", + [Char, Name, Escape]), + prepend_warning(Line, Column, Msg, Scope); + false -> + Scope + end, + Token = {char, {Line, Column, [$?, Char]}, Char}, + tokenize(T, Line, Column + 2, NewScope, [Token | Tokens]); + +% Heredocs + +tokenize("\"\"\"" ++ T, Line, Column, Scope, Tokens) -> + handle_heredocs(T, Line, Column, $", Scope, Tokens); + +%% TODO: Remove me in Elixir v2.0 +tokenize("'''" ++ T, Line, Column, Scope, Tokens) -> + NewScope = prepend_warning(Line, Column, "single-quoted string represent charlists. Use ~c''' if you indeed want a charlist or use \"\"\" instead", Scope), + handle_heredocs(T, Line, Column, $', NewScope, Tokens); + +% Strings + +tokenize([$" | T], Line, Column, Scope, Tokens) -> + handle_strings(T, Line, Column + 1, $", Scope, Tokens); + +%% TODO: Remove me in Elixir v2.0 +tokenize([$' | T], Line, Column, Scope, Tokens) -> + NewScope = prepend_warning(Line, Column, "single-quoted strings represent charlists. Use ~c\"\" if you indeed want a charlist or use \"\" instead", Scope), + handle_strings(T, Line, Column + 1, $', NewScope, Tokens); + +% Operator atoms + +tokenize(".:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 2, Scope, [{kw_identifier, {Line, Column, nil}, '.'} | Tokens]); + +tokenize("<<>>:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 5, Scope, [{kw_identifier, {Line, Column, nil}, '<<>>'} | Tokens]); +tokenize("%{}:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 4, Scope, [{kw_identifier, {Line, Column, nil}, '%{}'} | Tokens]); +tokenize("%:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 2, Scope, [{kw_identifier, {Line, Column, nil}, '%'} | Tokens]); +tokenize("&:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 2, Scope, [{kw_identifier, {Line, Column, nil}, '&'} | Tokens]); +tokenize("{}:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 3, Scope, [{kw_identifier, {Line, Column, nil}, '{}'} | Tokens]); +tokenize("..//:" ++ Rest, Line, Column, Scope, Tokens) when ?is_space(hd(Rest)) -> + tokenize(Rest, Line, Column + 5, Scope, [{kw_identifier, {Line, Column, nil}, '..//'} | Tokens]); + +tokenize(":<<>>" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize(Rest, Line, Column + 5, Scope, [{atom, {Line, Column, nil}, '<<>>'} | Tokens]); +tokenize(":%{}" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize(Rest, Line, Column + 4, Scope, [{atom, {Line, Column, nil}, '%{}'} | Tokens]); +tokenize(":%" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize(Rest, Line, Column + 2, Scope, [{atom, {Line, Column, nil}, '%'} | Tokens]); +tokenize(":{}" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize(Rest, Line, Column + 3, Scope, [{atom, {Line, Column, nil}, '{}'} | Tokens]); +tokenize(":..//" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize(Rest, Line, Column + 5, Scope, [{atom, {Line, Column, nil}, '..//'} | Tokens]); + +% ## Three Token Operators +tokenize([$:, T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when + ?unary_op3(T1, T2, T3); ?comp_op3(T1, T2, T3); ?and_op3(T1, T2, T3); ?or_op3(T1, T2, T3); + ?arrow_op3(T1, T2, T3); ?xor_op3(T1, T2, T3); ?concat_op3(T1, T2, T3); ?ellipsis_op3(T1, T2, T3) -> + Token = {atom, {Line, Column, nil}, list_to_atom([T1, T2, T3])}, + tokenize(Rest, Line, Column + 4, Scope, [Token | Tokens]); + +% ## Two Token Operators + +tokenize([$:, $:, $: | Rest], Line, Column, Scope, Tokens) -> + Message = "atom ::: must be written between quotes, as in :\"::\", to avoid ambiguity", + NewScope = prepend_warning(Line, Column, Message, Scope), + Token = {atom, {Line, Column, nil}, '::'}, + tokenize(Rest, Line, Column + 3, NewScope, [Token | Tokens]); + +tokenize([$:, T1, T2 | Rest], Line, Column, Scope, Tokens) when + ?comp_op2(T1, T2); ?rel_op2(T1, T2); ?and_op(T1, T2); ?or_op(T1, T2); + ?arrow_op(T1, T2); ?in_match_op(T1, T2); ?concat_op(T1, T2); ?power_op(T1, T2); + ?stab_op(T1, T2); ?range_op(T1, T2) -> + Token = {atom, {Line, Column, nil}, list_to_atom([T1, T2])}, + tokenize(Rest, Line, Column + 3, Scope, [Token | Tokens]); + +% ## Single Token Operators +tokenize([$:, T | Rest], Line, Column, Scope, Tokens) when + ?at_op(T); ?unary_op(T); ?capture_op(T); ?dual_op(T); ?mult_op(T); + ?rel_op(T); ?match_op(T); ?pipe_op(T); T =:= $. -> + Token = {atom, {Line, Column, nil}, list_to_atom([T])}, + tokenize(Rest, Line, Column + 2, Scope, [Token | Tokens]); + +% ## Stand-alone tokens + +tokenize("=>" ++ Rest, Line, Column, Scope, Tokens) -> + Token = {assoc_op, {Line, Column, previous_was_eol(Tokens)}, '=>'}, + tokenize(Rest, Line, Column + 2, Scope, add_token_with_eol(Token, Tokens)); + +tokenize("..//" ++ Rest = String, Line, Column, Scope, Tokens) -> + case strip_horizontal_space(Rest, 0) of + {[$/ | _] = Remaining, Extra} -> + Token = {identifier, {Line, Column, nil}, '..//'}, + tokenize(Remaining, Line, Column + 4 + Extra, Scope, [Token | Tokens]); + {_, _} -> + unexpected_token(String, Line, Column, Scope, Tokens) + end; + +% ## Ternary operator + +% ## Three token operators +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?unary_op3(T1, T2, T3) -> + handle_unary_op(Rest, Line, Column, unary_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?ellipsis_op3(T1, T2, T3) -> + handle_unary_op(Rest, Line, Column, ellipsis_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?comp_op3(T1, T2, T3) -> + handle_op(Rest, Line, Column, comp_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?and_op3(T1, T2, T3) -> + NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope), + handle_op(Rest, Line, Column, and_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?or_op3(T1, T2, T3) -> + NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope), + handle_op(Rest, Line, Column, or_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?xor_op3(T1, T2, T3) -> + NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope), + handle_op(Rest, Line, Column, xor_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?concat_op3(T1, T2, T3) -> + NewScope = maybe_warn_too_many_of_same_char([T1, T2, T3], Rest, Line, Column, Scope), + handle_op(Rest, Line, Column, concat_op, 3, list_to_atom([T1, T2, T3]), NewScope, Tokens); + +tokenize([T1, T2, T3 | Rest], Line, Column, Scope, Tokens) when ?arrow_op3(T1, T2, T3) -> + handle_op(Rest, Line, Column, arrow_op, 3, list_to_atom([T1, T2, T3]), Scope, Tokens); + +% ## Containers + punctuation tokens +tokenize([$, | Rest], Line, Column, Scope, Tokens) -> + Token = {',', {Line, Column, 0}}, + tokenize(Rest, Line, Column + 1, Scope, [Token | Tokens]); + +tokenize([$<, $< | Rest], Line, Column, Scope, Tokens) -> + Token = {'<<', {Line, Column, nil}}, + handle_terminator(Rest, Line, Column + 2, Scope, Token, Tokens); + +tokenize([$>, $> | Rest], Line, Column, Scope, Tokens) -> + Token = {'>>', {Line, Column, previous_was_eol(Tokens)}}, + handle_terminator(Rest, Line, Column + 2, Scope, Token, Tokens); + +tokenize([${ | Rest], Line, Column, Scope, [{'%', _} | _] = Tokens) -> + Message = + "unexpected space between % and {\n\n" + "If you want to define a map, write %{...}, with no spaces.\n" + "If you want to define a struct, write %StructName{...}.\n\n" + "Syntax error before: ", + error({?LOC(Line, Column), Message, [${]}, Rest, Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when T =:= $(; T =:= ${; T =:= $[ -> + Token = {list_to_atom([T]), {Line, Column, nil}}, + handle_terminator(Rest, Line, Column + 1, Scope, Token, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when T =:= $); T =:= $}; T =:= $] -> + Token = {list_to_atom([T]), {Line, Column, previous_was_eol(Tokens)}}, + handle_terminator(Rest, Line, Column + 1, Scope, Token, Tokens); + +% ## Two Token Operators +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?ternary_op(T1, T2) -> + Op = list_to_atom([T1, T2]), + Token = {ternary_op, {Line, Column, previous_was_eol(Tokens)}, Op}, + tokenize(Rest, Line, Column + 2, Scope, add_token_with_eol(Token, Tokens)); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?power_op(T1, T2) -> + handle_op(Rest, Line, Column, power_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?range_op(T1, T2) -> + handle_op(Rest, Line, Column, range_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?concat_op(T1, T2) -> + handle_op(Rest, Line, Column, concat_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?arrow_op(T1, T2) -> + handle_op(Rest, Line, Column, arrow_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?comp_op2(T1, T2) -> + handle_op(Rest, Line, Column, comp_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?rel_op2(T1, T2) -> + handle_op(Rest, Line, Column, rel_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?and_op(T1, T2) -> + handle_op(Rest, Line, Column, and_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?or_op(T1, T2) -> + handle_op(Rest, Line, Column, or_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?in_match_op(T1, T2) -> + handle_op(Rest, Line, Column, in_match_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?type_op(T1, T2) -> + handle_op(Rest, Line, Column, type_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +tokenize([T1, T2 | Rest], Line, Column, Scope, Tokens) when ?stab_op(T1, T2) -> + handle_op(Rest, Line, Column, stab_op, 2, list_to_atom([T1, T2]), Scope, Tokens); + +% ## Single Token Operators + +tokenize([$& | Rest], Line, Column, Scope, Tokens) -> + Kind = + case strip_horizontal_space(Rest, 0) of + {[Int | _], 0} when ?is_digit(Int) -> + capture_int; + + {[$/ | NewRest], _} -> + case strip_horizontal_space(NewRest, 0) of + {[$/ | _], _} -> capture_op; + {_, _} -> identifier + end; + + {_, _} -> + capture_op + end, + + Token = {Kind, {Line, Column, nil}, '&'}, + tokenize(Rest, Line, Column + 1, Scope, [Token | Tokens]); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?at_op(T) -> + handle_unary_op(Rest, Line, Column, at_op, 1, list_to_atom([T]), Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?unary_op(T) -> + handle_unary_op(Rest, Line, Column, unary_op, 1, list_to_atom([T]), Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?rel_op(T) -> + handle_op(Rest, Line, Column, rel_op, 1, list_to_atom([T]), Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?dual_op(T) -> + handle_unary_op(Rest, Line, Column, dual_op, 1, list_to_atom([T]), Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?mult_op(T) -> + handle_op(Rest, Line, Column, mult_op, 1, list_to_atom([T]), Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?match_op(T) -> + handle_op(Rest, Line, Column, match_op, 1, list_to_atom([T]), Scope, Tokens); + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?pipe_op(T) -> + handle_op(Rest, Line, Column, pipe_op, 1, list_to_atom([T]), Scope, Tokens); + +% Non-operator Atoms + +tokenize([$:, H | T] = Original, Line, Column, Scope, Tokens) when ?is_quote(H) -> + case future_elixir_interpolation:extract(Line, Column + 2, Scope, true, T, H) of + {NewLine, NewColumn, Parts, Rest, InterScope} -> + NewScope = case is_unnecessary_quote(Parts, InterScope) of + true -> + WarnMsg = io_lib:format( + "found quoted atom \"~ts\" but the quotes are not required. " + "Atoms made exclusively of ASCII letters, numbers, underscores, " + "beginning with a letter or underscore, and optionally ending with ! or ? " + "do not require quotes", + [hd(Parts)] + ), + prepend_warning(Line, Column, WarnMsg, InterScope); + + false -> + InterScope + end, + + case unescape_tokens(Parts, Line, Column, NewScope) of + {ok, [Part]} when is_binary(Part) -> + case unsafe_to_atom(Part, Line, Column, Scope) of + {ok, Atom} -> + Token = {atom_quoted, {Line, Column, nil}, Atom}, + tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]); + + {error, Reason} -> + error(Reason, Rest, NewScope, Tokens) + end; + + {ok, Unescaped} -> + Key = case Scope#elixir_tokenizer.existing_atoms_only of + true -> atom_safe; + false -> atom_unsafe + end, + Token = {Key, {Line, Column, nil}, Unescaped}, + tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]); + + {error, Reason} -> + error(Reason, Rest, NewScope, Tokens) + end; + + {error, Reason} -> + Message = " (for atom starting at line ~B)", + interpolation_error(Reason, Original, Scope, Tokens, Message, [Line], Line, Column + 1, [H], [H]) + end; + +tokenize([$: | String] = Original, Line, Column, Scope, Tokens) -> + case tokenize_identifier(String, Line, Column, Scope, false) of + {_Kind, Unencoded, Atom, Rest, Length, Ascii, _Special} -> + NewScope = maybe_warn_for_ambiguous_bang_before_equals(atom, Unencoded, Rest, Line, Column, Scope), + TrackedScope = track_ascii(Ascii, NewScope), + Token = {atom, {Line, Column, Unencoded}, Atom}, + tokenize(Rest, Line, Column + 1 + Length, TrackedScope, [Token | Tokens]); + empty when Scope#elixir_tokenizer.cursor_completion == false -> + unexpected_token(Original, Line, Column, Scope, Tokens); + empty -> + tokenize([], Line, Column, Scope, Tokens); + {unexpected_token, Length} -> + unexpected_token(lists:nthtail(Length - 1, String), Line, Column + Length - 1, Scope, Tokens); + {error, Reason} -> + error(Reason, Original, Scope, Tokens) + end; + +% Integers and floats +% We use int and flt otherwise elixir_parser won't format them +% properly in case of errors. + +tokenize([H | T], Line, Column, Scope, Tokens) when ?is_digit(H) -> + case tokenize_number(T, [H], 1, false) of + {error, Reason, Original} -> + error({?LOC(Line, Column), Reason, Original}, T, Scope, Tokens); + {[I | Rest], Number, Original, _Length} when ?is_upcase(I); ?is_downcase(I); I == $_ -> + if + Number == 0, (I =:= $x) orelse (I =:= $o) orelse (I =:= $b), Rest == [], + Scope#elixir_tokenizer.cursor_completion /= false -> + tokenize([], Line, Column, Scope, Tokens); + + true -> + Msg = + io_lib:format( + "invalid character \"~ts\" after number ~ts. If you intended to write a number, " + "make sure to separate the number from the character (using comma, space, etc). " + "If you meant to write a function name or a variable, note that identifiers in " + "Elixir cannot start with numbers. Unexpected token: ", + [[I], Original] + ), + + error({?LOC(Line, Column), Msg, [I]}, T, Scope, Tokens) + end; + {Rest, Number, Original, Length} when is_integer(Number) -> + Token = {int, {Line, Column, Number}, Original}, + tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]); + {Rest, Number, Original, Length} -> + Token = {flt, {Line, Column, Number}, Original}, + tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]) + end; + +% Spaces + +tokenize([T | Rest], Line, Column, Scope, Tokens) when ?is_horizontal_space(T) -> + {Remaining, Stripped} = strip_horizontal_space(Rest, 0), + handle_space_sensitive_tokens(Remaining, Line, Column + 1 + Stripped, Scope, Tokens); + +% End of line + +tokenize(";" ++ Rest, Line, Column, Scope, []) -> + tokenize(Rest, Line, Column + 1, Scope, [{';', {Line, Column, 0}}]); + +tokenize(";" ++ Rest, Line, Column, Scope, [Top | _] = Tokens) when element(1, Top) /= ';' -> + tokenize(Rest, Line, Column + 1, Scope, [{';', {Line, Column, 0}} | Tokens]); + +tokenize("\\" = Original, Line, Column, Scope, Tokens) -> + error({?LOC(Line, Column), "invalid escape \\ at end of file", []}, Original, Scope, Tokens); + +tokenize("\\\n" = Original, Line, Column, Scope, Tokens) -> + error({?LOC(Line, Column), "invalid escape \\ at end of file", []}, Original, Scope, Tokens); + +tokenize("\\\r\n" = Original, Line, Column, Scope, Tokens) -> + error({?LOC(Line, Column), "invalid escape \\ at end of file", []}, Original, Scope, Tokens); + +tokenize("\\\n" ++ Rest, Line, _Column, Scope, Tokens) -> + tokenize_eol(Rest, Line, Scope, Tokens); + +tokenize("\\\r\n" ++ Rest, Line, _Column, Scope, Tokens) -> + tokenize_eol(Rest, Line, Scope, Tokens); + +tokenize("\n" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize_eol(Rest, Line, Scope, eol(Line, Column, Tokens)); + +tokenize("\r\n" ++ Rest, Line, Column, Scope, Tokens) -> + tokenize_eol(Rest, Line, Scope, eol(Line, Column, Tokens)); + +% Others + +tokenize([$%, $( | Rest], Line, Column, Scope, Tokens) -> + Reason = {?LOC(Line, Column), "expected %{ to define a map, got: ", [$%, $(]}, + error(Reason, Rest, Scope, Tokens); + +tokenize([$%, $[ | Rest], Line, Column, Scope, Tokens) -> + Reason = {?LOC(Line, Column), "expected %{ to define a map, got: ", [$%, $[]}, + error(Reason, Rest, Scope, Tokens); + +tokenize([$%, ${ | T], Line, Column, Scope, Tokens) -> + tokenize([${ | T], Line, Column + 1, Scope, [{'%{}', {Line, Column, nil}} | Tokens]); + +tokenize([$% | T], Line, Column, Scope, Tokens) -> + tokenize(T, Line, Column + 1, Scope, [{'%', {Line, Column, nil}} | Tokens]); + +tokenize([$. | T], Line, Column, Scope, Tokens) -> + tokenize_dot(T, Line, Column + 1, {Line, Column, nil}, Scope, Tokens); + +% Identifiers + +tokenize(String, Line, Column, OriginalScope, Tokens) -> + case tokenize_identifier(String, Line, Column, OriginalScope, not previous_was_dot(Tokens)) of + {Kind, Unencoded, Atom, Rest, Length, Ascii, Special} -> + HasAt = lists:member(at, Special), + Scope = track_ascii(Ascii, OriginalScope), + + case Rest of + [$: | T] when ?is_space(hd(T)) -> + Token = {kw_identifier, {Line, Column, Unencoded}, Atom}, + tokenize(T, Line, Column + Length + 1, Scope, [Token | Tokens]); + + [$: | T] when hd(T) =/= $: -> + AtomName = atom_to_list(Atom) ++ [$:], + Reason = {?LOC(Line, Column), "keyword argument must be followed by space after: ", AtomName}, + error(Reason, String, Scope, Tokens); + + _ when HasAt -> + Reason = {?LOC(Line, Column), invalid_character_error(Kind, $@), atom_to_list(Atom)}, + error(Reason, String, Scope, Tokens); + + _ when Atom == '__aliases__'; Atom == '__block__' -> + error({?LOC(Line, Column), "reserved token: ", atom_to_list(Atom)}, Rest, Scope, Tokens); + + _ when Kind == alias -> + tokenize_alias(Rest, Line, Column, Unencoded, Atom, Length, Ascii, Special, Scope, Tokens); + + _ when Kind == identifier -> + NewScope = maybe_warn_for_ambiguous_bang_before_equals(identifier, Unencoded, Rest, Line, Column, Scope), + Token = check_call_identifier(Line, Column, Unencoded, Atom, Rest), + tokenize(Rest, Line, Column + Length, NewScope, [Token | Tokens]); + + _ -> + unexpected_token(String, Line, Column, Scope, Tokens) + end; + + {keyword, Atom, Type, Rest, Length} -> + tokenize_keyword(Type, Rest, Line, Column, Atom, Length, OriginalScope, Tokens); + + empty when OriginalScope#elixir_tokenizer.cursor_completion == false -> + unexpected_token(String, Line, Column, OriginalScope, Tokens); + + empty -> + case String of + [$~, L] when ?is_upcase(L); ?is_downcase(L) -> tokenize([], Line, Column, OriginalScope, Tokens); + [$~] -> tokenize([], Line, Column, OriginalScope, Tokens); + _ -> unexpected_token(String, Line, Column, OriginalScope, Tokens) + end; + + {unexpected_token, Length} -> + unexpected_token(lists:nthtail(Length - 1, String), Line, Column + Length - 1, OriginalScope, Tokens); + + {error, Reason} -> + error(Reason, String, OriginalScope, Tokens) + end. + +previous_was_dot([{'.', _} | _]) -> true; +previous_was_dot(_) -> false. + +unexpected_token([T | Rest], Line, Column, Scope, Tokens) -> + Message = + case handle_char(T) of + {_Escaped, Explanation} -> + io_lib:format("~ts (column ~p, code point U+~4.16.0B)", [Explanation, Column, T]); + false -> + io_lib:format("\"~ts\" (column ~p, code point U+~4.16.0B)", [[T], Column, T]) + end, + error({?LOC(Line, Column), "unexpected token: ", Message}, Rest, Scope, Tokens). + +tokenize_eol(Rest, Line, Scope, Tokens) -> + {StrippedRest, Column} = strip_horizontal_space(Rest, Scope#elixir_tokenizer.column), + IndentedScope = Scope#elixir_tokenizer{indentation=Column-1}, + tokenize(StrippedRest, Line + 1, Column, IndentedScope, Tokens). + +strip_horizontal_space([H | T], Counter) when ?is_horizontal_space(H) -> + strip_horizontal_space(T, Counter + 1); +strip_horizontal_space(T, Counter) -> + {T, Counter}. + +tokenize_dot(T, Line, Column, DotInfo, Scope, Tokens) -> + case strip_horizontal_space(T, 0) of + {[$# | R], _} -> + case tokenize_comment(R, [$#]) of + {error, Char} -> + error_comment(Char, [$# | R], Line, Column, Scope, Tokens); + + {Rest, Comment} -> + preserve_comments(Line, Column, Tokens, Comment, Rest, Scope), + tokenize_dot(Rest, Line, Scope#elixir_tokenizer.column, DotInfo, Scope, Tokens) + end; + {"\r\n" ++ Rest, _} -> + tokenize_dot(Rest, Line + 1, Scope#elixir_tokenizer.column, DotInfo, Scope, Tokens); + {"\n" ++ Rest, _} -> + tokenize_dot(Rest, Line + 1, Scope#elixir_tokenizer.column, DotInfo, Scope, Tokens); + {Rest, Length} -> + handle_dot([$. | Rest], Line, Column + Length, DotInfo, Scope, Tokens) + end. + +handle_char(0) -> {"\\0", "null byte"}; +handle_char(7) -> {"\\a", "alert"}; +handle_char($\b) -> {"\\b", "backspace"}; +handle_char($\d) -> {"\\d", "delete"}; +handle_char($\e) -> {"\\e", "escape"}; +handle_char($\f) -> {"\\f", "form feed"}; +handle_char($\n) -> {"\\n", "newline"}; +handle_char($\r) -> {"\\r", "carriage return"}; +handle_char($\s) -> {"\\s", "space"}; +handle_char($\t) -> {"\\t", "tab"}; +handle_char($\v) -> {"\\v", "vertical tab"}; +handle_char(_) -> false. + +%% Handlers + +handle_heredocs(T, Line, Column, H, Scope, Tokens) -> + case extract_heredoc_with_interpolation(Line, Column, Scope, true, T, H) of + {ok, NewLine, NewColumn, Parts, Rest, NewScope} -> + case unescape_tokens(Parts, Line, Column, NewScope) of + {ok, Unescaped} -> + Token = {heredoc_type(H), {Line, Column, nil}, NewColumn - 4, Unescaped}, + tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]); + + {error, Reason} -> + error(Reason, Rest, Scope, Tokens) + end; + + {error, Reason} -> + error(Reason, [H, H, H] ++ T, Scope, Tokens) + end. + +handle_strings(T, Line, Column, H, Scope, Tokens) -> + case future_elixir_interpolation:extract(Line, Column, Scope, true, T, H) of + {error, Reason} -> + interpolation_error(Reason, [H | T], Scope, Tokens, " (for string starting at line ~B)", [Line], Line, Column-1, [H], [H]); + + {NewLine, NewColumn, Parts, [$: | Rest], InterScope} when ?is_space(hd(Rest)) -> + NewScope = case is_unnecessary_quote(Parts, InterScope) of + true -> + WarnMsg = io_lib:format( + "found quoted keyword \"~ts\" but the quotes are not required. " + "Note that keywords are always atoms, even when quoted. " + "Similar to atoms, keywords made exclusively of ASCII " + "letters, numbers, and underscores and not beginning with a " + "number do not require quotes", + [hd(Parts)] + ), + prepend_warning(Line, Column, WarnMsg, InterScope); + + false -> + InterScope + end, + + case unescape_tokens(Parts, Line, Column, NewScope) of + {ok, [Part]} when is_binary(Part) -> + case unsafe_to_atom(Part, Line, Column - 1, Scope) of + {ok, Atom} -> + Token = {kw_identifier, {Line, Column - 1, nil}, Atom}, + tokenize(Rest, NewLine, NewColumn + 1, NewScope, [Token | Tokens]); + {error, Reason} -> + error(Reason, Rest, NewScope, Tokens) + end; + + {ok, Unescaped} -> + Key = case Scope#elixir_tokenizer.existing_atoms_only of + true -> kw_identifier_safe; + false -> kw_identifier_unsafe + end, + Token = {Key, {Line, Column - 1, nil}, Unescaped}, + tokenize(Rest, NewLine, NewColumn + 1, NewScope, [Token | Tokens]); + + {error, Reason} -> + error(Reason, Rest, NewScope, Tokens) + end; + + {NewLine, NewColumn, Parts, Rest, NewScope} -> + case unescape_tokens(Parts, Line, Column, NewScope) of + {ok, Unescaped} -> + Token = {string_type(H), {Line, Column - 1, nil}, Unescaped}, + tokenize(Rest, NewLine, NewColumn, NewScope, [Token | Tokens]); + + {error, Reason} -> + error(Reason, Rest, NewScope, Tokens) + end + end. + +handle_unary_op([$: | Rest], Line, Column, _Kind, Length, Op, Scope, Tokens) when ?is_space(hd(Rest)) -> + Token = {kw_identifier, {Line, Column, nil}, Op}, + tokenize(Rest, Line, Column + Length + 1, Scope, [Token | Tokens]); + +handle_unary_op(Rest, Line, Column, Kind, Length, Op, Scope, Tokens) -> + case strip_horizontal_space(Rest, 0) of + {[$/ | _] = Remaining, Extra} -> + Token = {identifier, {Line, Column, nil}, Op}, + tokenize(Remaining, Line, Column + Length + Extra, Scope, [Token | Tokens]); + {Remaining, Extra} -> + Token = {Kind, {Line, Column, nil}, Op}, + tokenize(Remaining, Line, Column + Length + Extra, Scope, [Token | Tokens]) + end. + +handle_op([$: | Rest], Line, Column, _Kind, Length, Op, Scope, Tokens) when ?is_space(hd(Rest)) -> + Token = {kw_identifier, {Line, Column, nil}, Op}, + tokenize(Rest, Line, Column + Length + 1, Scope, [Token | Tokens]); + +handle_op(Rest, Line, Column, Kind, Length, Op, Scope, Tokens) -> + case strip_horizontal_space(Rest, 0) of + {[$/ | _] = Remaining, Extra} -> + Token = {identifier, {Line, Column, nil}, Op}, + tokenize(Remaining, Line, Column + Length + Extra, Scope, [Token | Tokens]); + {Remaining, Extra} -> + NewScope = + %% TODO: Remove these deprecations on Elixir v2.0 + case Op of + '^^^' -> + Msg = "^^^ is deprecated. It is typically used as xor but it has the wrong precedence, use Bitwise.bxor/2 instead", + prepend_warning(Line, Column, Msg, Scope); + + '~~~' -> + Msg = "~~~ is deprecated. Use Bitwise.bnot/1 instead for clarity", + prepend_warning(Line, Column, Msg, Scope); + + '<|>' -> + Msg = "<|> is deprecated. Use another pipe-like operator", + prepend_warning(Line, Column, Msg, Scope); + + _ -> + Scope + end, + + Token = {Kind, {Line, Column, previous_was_eol(Tokens)}, Op}, + tokenize(Remaining, Line, Column + Length + Extra, NewScope, add_token_with_eol(Token, Tokens)) + end. + +% ## Three Token Operators +handle_dot([$., T1, T2, T3 | Rest], Line, Column, DotInfo, Scope, Tokens) when + ?unary_op3(T1, T2, T3); ?comp_op3(T1, T2, T3); ?and_op3(T1, T2, T3); ?or_op3(T1, T2, T3); + ?arrow_op3(T1, T2, T3); ?xor_op3(T1, T2, T3); ?concat_op3(T1, T2, T3) -> + handle_call_identifier(Rest, Line, Column, DotInfo, 3, [T1, T2, T3], Scope, Tokens); + +% ## Two Token Operators +handle_dot([$., T1, T2 | Rest], Line, Column, DotInfo, Scope, Tokens) when + ?comp_op2(T1, T2); ?rel_op2(T1, T2); ?and_op(T1, T2); ?or_op(T1, T2); + ?arrow_op(T1, T2); ?in_match_op(T1, T2); ?concat_op(T1, T2); ?power_op(T1, T2); + ?type_op(T1, T2) -> + handle_call_identifier(Rest, Line, Column, DotInfo, 2, [T1, T2], Scope, Tokens); + +% ## Single Token Operators +handle_dot([$., T | Rest], Line, Column, DotInfo, Scope, Tokens) when + ?at_op(T); ?unary_op(T); ?capture_op(T); ?dual_op(T); ?mult_op(T); + ?rel_op(T); ?match_op(T); ?pipe_op(T) -> + handle_call_identifier(Rest, Line, Column, DotInfo, 1, [T], Scope, Tokens); + +% ## Exception for .( as it needs to be treated specially in the parser +handle_dot([$., $( | Rest], Line, Column, DotInfo, Scope, Tokens) -> + TokensSoFar = add_token_with_eol({dot_call_op, DotInfo, '.'}, Tokens), + tokenize([$( | Rest], Line, Column, Scope, TokensSoFar); + +handle_dot([$., H | T] = Original, Line, Column, DotInfo, Scope, Tokens) when ?is_quote(H) -> + case future_elixir_interpolation:extract(Line, Column + 1, Scope, true, T, H) of + {NewLine, NewColumn, [Part], Rest, InterScope} when is_list(Part) -> + NewScope = case is_unnecessary_quote([Part], InterScope) of + true -> + WarnMsg = io_lib:format( + "found quoted call \"~ts\" but the quotes are not required. " + "Calls made exclusively of Unicode letters, numbers, and underscores " + "and not beginning with a number do not require quotes", + [Part] + ), + prepend_warning(Line, Column, WarnMsg, InterScope); + + false -> + InterScope + end, + + case unsafe_to_atom(Part, Line, Column, NewScope) of + {ok, Atom} -> + Token = check_call_identifier(Line, Column, Part, Atom, Rest), + TokensSoFar = add_token_with_eol({'.', DotInfo}, Tokens), + tokenize(Rest, NewLine, NewColumn, NewScope, [Token | TokensSoFar]); + + {error, Reason} -> + error(Reason, Original, NewScope, Tokens) + end; + {_NewLine, _NewColumn, _Parts, Rest, NewScope} -> + Message = "interpolation is not allowed when calling function/macro. Found interpolation in a call starting with: ", + error({?LOC(Line, Column), Message, [H]}, Rest, NewScope, Tokens); + {error, Reason} -> + interpolation_error(Reason, Original, Scope, Tokens, " (for function name starting at line ~B)", [Line], Line, Column, [H], [H]) + end; + +handle_dot([$. | Rest], Line, Column, DotInfo, Scope, Tokens) -> + TokensSoFar = add_token_with_eol({'.', DotInfo}, Tokens), + tokenize(Rest, Line, Column, Scope, TokensSoFar). + +handle_call_identifier(Rest, Line, Column, DotInfo, Length, UnencodedOp, Scope, Tokens) -> + Token = check_call_identifier(Line, Column, UnencodedOp, list_to_atom(UnencodedOp), Rest), + TokensSoFar = add_token_with_eol({'.', DotInfo}, Tokens), + tokenize(Rest, Line, Column + Length, Scope, [Token | TokensSoFar]). + +% ## Ambiguous unary/binary operators tokens +% Keywords are not ambiguous operators +handle_space_sensitive_tokens([Sign, $:, Space | _] = String, Line, Column, Scope, Tokens) when ?dual_op(Sign), ?is_space(Space) -> + tokenize(String, Line, Column, Scope, Tokens); + +% But everything else, except other operators, are +handle_space_sensitive_tokens([Sign, NotMarker | T], Line, Column, Scope, [{identifier, _, _} = H | Tokens]) when + ?dual_op(Sign), not(?is_space(NotMarker)), NotMarker =/= Sign, NotMarker =/= $/, NotMarker =/= $> -> + Rest = [NotMarker | T], + DualOpToken = {dual_op, {Line, Column, nil}, list_to_atom([Sign])}, + tokenize(Rest, Line, Column + 1, Scope, [DualOpToken, setelement(1, H, op_identifier) | Tokens]); + +% Handle cursor completion +handle_space_sensitive_tokens([], Line, Column, + #elixir_tokenizer{cursor_completion=Cursor} = Scope, + [{identifier, Info, Identifier} | Tokens]) when Cursor /= false -> + tokenize([$(], Line, Column+1, Scope, [{paren_identifier, Info, Identifier} | Tokens]); + +handle_space_sensitive_tokens(String, Line, Column, Scope, Tokens) -> + tokenize(String, Line, Column, Scope, Tokens). + +%% Helpers + +eol(_Line, _Column, [{',', {Line, Column, Count}} | Tokens]) -> + [{',', {Line, Column, Count + 1}} | Tokens]; +eol(_Line, _Column, [{';', {Line, Column, Count}} | Tokens]) -> + [{';', {Line, Column, Count + 1}} | Tokens]; +eol(_Line, _Column, [{eol, {Line, Column, Count}} | Tokens]) -> + [{eol, {Line, Column, Count + 1}} | Tokens]; +eol(Line, Column, Tokens) -> + [{eol, {Line, Column, 1}} | Tokens]. + +is_unnecessary_quote([Part], Scope) when is_list(Part) -> + case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(Part) of + {identifier, _, [], _, true, Special} -> not lists:member(at, Special); + _ -> false + end; +is_unnecessary_quote(_Parts, _Scope) -> + false. + +unsafe_to_atom(Part, Line, Column, #elixir_tokenizer{}) when + is_binary(Part) andalso byte_size(Part) > 255; + is_list(Part) andalso length(Part) > 255 -> + {error, {?LOC(Line, Column), "atom length must be less than system limit: ", elixir_utils:characters_to_list(Part)}}; +unsafe_to_atom(Part, Line, Column, #elixir_tokenizer{static_atoms_encoder=StaticAtomsEncoder}) when + is_function(StaticAtomsEncoder) -> + Value = elixir_utils:characters_to_binary(Part), + case StaticAtomsEncoder(Value, [{line, Line}, {column, Column}]) of + {ok, Term} -> + {ok, Term}; + {error, Reason} when is_binary(Reason) -> + {error, {?LOC(Line, Column), elixir_utils:characters_to_list(Reason) ++ ": ", elixir_utils:characters_to_list(Part)}} + end; +unsafe_to_atom(Binary, Line, Column, #elixir_tokenizer{existing_atoms_only=true}) when is_binary(Binary) -> + try + {ok, binary_to_existing_atom(Binary, utf8)} + catch + error:badarg -> {error, {?LOC(Line, Column), "unsafe atom does not exist: ", elixir_utils:characters_to_list(Binary)}} + end; +unsafe_to_atom(Binary, _Line, _Column, #elixir_tokenizer{}) when is_binary(Binary) -> + {ok, binary_to_atom(Binary, utf8)}; +unsafe_to_atom(List, Line, Column, #elixir_tokenizer{existing_atoms_only=true}) when is_list(List) -> + try + {ok, list_to_existing_atom(List)} + catch + error:badarg -> {error, {?LOC(Line, Column), "unsafe atom does not exist: ", List}} + end; +unsafe_to_atom(List, _Line, _Column, #elixir_tokenizer{}) when is_list(List) -> + {ok, list_to_atom(List)}. + +collect_modifiers([H | T], Buffer) when ?is_downcase(H) or ?is_upcase(H) or ?is_digit(H) -> + collect_modifiers(T, [H | Buffer]); + +collect_modifiers(Rest, Buffer) -> + {Rest, lists:reverse(Buffer)}. + +%% Heredocs + +extract_heredoc_with_interpolation(Line, Column, Scope, Interpol, T, H) -> + case extract_heredoc_header(T) of + {ok, Headerless} -> + %% We prepend a new line so we can transparently remove + %% spaces later. This new line is removed by calling "tl" + %% in the final heredoc body three lines below. + case future_elixir_interpolation:extract(Line, Column, Scope, Interpol, [$\n|Headerless], [H,H,H]) of + {NewLine, NewColumn, Parts0, Rest, InterScope} -> + Indent = NewColumn - 4, + Fun = fun(Part, Acc) -> extract_heredoc_indent(Part, Acc, Indent) end, + {Parts1, {ShouldWarn, _}} = lists:mapfoldl(Fun, {false, Line}, Parts0), + Parts2 = extract_heredoc_head(Parts1), + NewScope = maybe_heredoc_warn(ShouldWarn, Column, InterScope, H), + {ok, NewLine, NewColumn, tokens_to_binary(Parts2), Rest, NewScope}; + + {error, Reason} -> + {error, interpolation_format(Reason, " (for heredoc starting at line ~B)", [Line], Line, Column, [H, H, H], [H, H, H])} + end; + + error -> + Message = "heredoc allows only whitespace characters followed by a new line after opening ", + {error, {?LOC(Line, Column + 3), io_lib:format(Message, []), [H, H, H]}} + end. + +extract_heredoc_header("\r\n" ++ Rest) -> + {ok, Rest}; +extract_heredoc_header("\n" ++ Rest) -> + {ok, Rest}; +extract_heredoc_header([H | T]) when ?is_horizontal_space(H) -> + extract_heredoc_header(T); +extract_heredoc_header(_) -> + error. + +extract_heredoc_indent(Part, {Warned, Line}, Indent) when is_list(Part) -> + extract_heredoc_indent(Part, [], Warned, Line, Indent); +extract_heredoc_indent({_, {EndLine, _, _}, _} = Part, {Warned, _Line}, _Indent) -> + {Part, {Warned, EndLine}}. + +extract_heredoc_indent([$\n | Rest], Acc, Warned, Line, Indent) -> + {Trimmed, ShouldWarn} = trim_space(Rest, Indent), + Warn = if ShouldWarn, not Warned -> Line + 1; true -> Warned end, + extract_heredoc_indent(Trimmed, [$\n | Acc], Warn, Line + 1, Indent); +extract_heredoc_indent([Head | Rest], Acc, Warned, Line, Indent) -> + extract_heredoc_indent(Rest, [Head | Acc], Warned, Line, Indent); +extract_heredoc_indent([], Acc, Warned, Line, _Indent) -> + {lists:reverse(Acc), {Warned, Line}}. + +trim_space(Rest, 0) -> {Rest, false}; +trim_space([$\r, $\n | _] = Rest, _) -> {Rest, false}; +trim_space([$\n | _] = Rest, _) -> {Rest, false}; +trim_space([H | T], Spaces) when ?is_horizontal_space(H) -> trim_space(T, Spaces - 1); +trim_space([], _Spaces) -> {[], false}; +trim_space(Rest, _Spaces) -> {Rest, true}. + +maybe_heredoc_warn(false, _Column, Scope, _Marker) -> + Scope; +maybe_heredoc_warn(Line, Column, Scope, Marker) -> + Msg = io_lib:format("outdented heredoc line. The contents inside the heredoc should be indented " + "at the same level as the closing ~ts. The following is forbidden:~n~n" + " def text do~n" + " \"\"\"~n" + " contents~n" + " \"\"\"~n" + " end~n~n" + "Instead make sure the contents are indented as much as the heredoc closing:~n~n" + " def text do~n" + " \"\"\"~n" + " contents~n" + " \"\"\"~n" + " end~n~n" + "The current heredoc line is indented too little", [[Marker, Marker, Marker]]), + + prepend_warning(Line, Column, Msg, Scope). + +extract_heredoc_head([[$\n|H]|T]) -> [H|T]. + +unescape_tokens(Tokens, Line, Column, #elixir_tokenizer{unescape=true}) -> + case future_elixir_interpolation:unescape_tokens(Tokens) of + {ok, Result} -> + {ok, Result}; + + {error, Message, Token} -> + {error, {?LOC(Line, Column), Message ++ ". Syntax error after: ", Token}} + end; +unescape_tokens(Tokens, _Line, _Column, #elixir_tokenizer{unescape=false}) -> + {ok, tokens_to_binary(Tokens)}. + +tokens_to_binary(Tokens) -> + [if is_list(Token) -> elixir_utils:characters_to_binary(Token); true -> Token end + || Token <- Tokens]. + +%% Integers and floats +%% At this point, we are at least sure the first digit is a number. + +%% Check if we have a point followed by a number; +tokenize_number([$., H | T], Acc, Length, false) when ?is_digit(H) -> + tokenize_number(T, [H, $. | Acc], Length + 2, true); + +%% Check if we have an underscore followed by a number; +tokenize_number([$_, H | T], Acc, Length, Bool) when ?is_digit(H) -> + tokenize_number(T, [H, $_ | Acc], Length + 2, Bool); + +%% Check if we have e- followed by numbers (valid only for floats); +tokenize_number([E, S, H | T], Acc, Length, true) + when (E =:= $E) or (E =:= $e), ?is_digit(H), S =:= $+ orelse S =:= $- -> + tokenize_number(T, [H, S, E | Acc], Length + 3, true); + +%% Check if we have e followed by numbers (valid only for floats); +tokenize_number([E, H | T], Acc, Length, true) + when (E =:= $E) or (E =:= $e), ?is_digit(H) -> + tokenize_number(T, [H, E | Acc], Length + 2, true); + +%% Finally just numbers. +tokenize_number([H | T], Acc, Length, Bool) when ?is_digit(H) -> + tokenize_number(T, [H | Acc], Length + 1, Bool); + +%% Cast to float... +tokenize_number(Rest, Acc, Length, true) -> + try + {Number, Original} = reverse_number(Acc, [], []), + {Rest, list_to_float(Number), Original, Length} + catch + error:badarg -> {error, "invalid float number ", lists:reverse(Acc)} + end; + +%% Or integer. +tokenize_number(Rest, Acc, Length, false) -> + {Number, Original} = reverse_number(Acc, [], []), + {Rest, list_to_integer(Number), Original, Length}. + +tokenize_hex([H | T], Acc, Length) when ?is_hex(H) -> + tokenize_hex(T, [H | Acc], Length + 1); +tokenize_hex([$_, H | T], Acc, Length) when ?is_hex(H) -> + tokenize_hex(T, [H, $_ | Acc], Length + 2); +tokenize_hex(Rest, Acc, Length) -> + {Number, Original} = reverse_number(Acc, [], []), + {Rest, list_to_integer(Number, 16), [$0, $x | Original], Length}. + +tokenize_octal([H | T], Acc, Length) when ?is_octal(H) -> + tokenize_octal(T, [H | Acc], Length + 1); +tokenize_octal([$_, H | T], Acc, Length) when ?is_octal(H) -> + tokenize_octal(T, [H, $_ | Acc], Length + 2); +tokenize_octal(Rest, Acc, Length) -> + {Number, Original} = reverse_number(Acc, [], []), + {Rest, list_to_integer(Number, 8), [$0, $o | Original], Length}. + +tokenize_bin([H | T], Acc, Length) when ?is_bin(H) -> + tokenize_bin(T, [H | Acc], Length + 1); +tokenize_bin([$_, H | T], Acc, Length) when ?is_bin(H) -> + tokenize_bin(T, [H, $_ | Acc], Length + 2); +tokenize_bin(Rest, Acc, Length) -> + {Number, Original} = reverse_number(Acc, [], []), + {Rest, list_to_integer(Number, 2), [$0, $b | Original], Length}. + +reverse_number([$_ | T], Number, Original) -> + reverse_number(T, Number, [$_ | Original]); +reverse_number([H | T], Number, Original) -> + reverse_number(T, [H | Number], [H | Original]); +reverse_number([], Number, Original) -> + {Number, Original}. + +%% Comments + +reset_eol([{eol, {Line, Column, _}} | Rest]) -> [{eol, {Line, Column, 0}} | Rest]; +reset_eol(Rest) -> Rest. + +tokenize_comment("\r\n" ++ _ = Rest, Acc) -> + {Rest, lists:reverse(Acc)}; +tokenize_comment("\n" ++ _ = Rest, Acc) -> + {Rest, lists:reverse(Acc)}; +tokenize_comment([H | _Rest], _) when ?bidi(H) -> + {error, H}; +tokenize_comment([H | Rest], Acc) -> + tokenize_comment(Rest, [H | Acc]); +tokenize_comment([], Acc) -> + {[], lists:reverse(Acc)}. + +error_comment(H, Comment, Line, Column, Scope, Tokens) -> + Token = io_lib:format("\\u~4.16.0B", [H]), + Reason = {?LOC(Line, Column), "invalid bidirectional formatting character in comment: ", Token}, + error(Reason, Comment, Scope, Tokens). + +preserve_comments(Line, Column, Tokens, Comment, Rest, Scope) -> + case Scope#elixir_tokenizer.preserve_comments of + Fun when is_function(Fun) -> + Fun(Line, Column, Tokens, Comment, Rest); + nil -> + ok + end. + +%% Identifiers + +tokenize([H | T]) when ?is_upcase(H) -> + {Acc, Rest, Length, Special} = tokenize_continue(T, [H], 1, []), + {alias, lists:reverse(Acc), Rest, Length, true, Special}; +tokenize([H | T]) when ?is_downcase(H); H =:= $_ -> + {Acc, Rest, Length, Special} = tokenize_continue(T, [H], 1, []), + {identifier, lists:reverse(Acc), Rest, Length, true, Special}; +tokenize(_List) -> + {error, empty}. + +tokenize_continue([$@ | T], Acc, Length, Special) -> + tokenize_continue(T, [$@ | Acc], Length + 1, [at | lists:delete(at, Special)]); +tokenize_continue([$! | T], Acc, Length, Special) -> + {[$! | Acc], T, Length + 1, [punctuation | Special]}; +tokenize_continue([$? | T], Acc, Length, Special) -> + {[$? | Acc], T, Length + 1, [punctuation | Special]}; +tokenize_continue([H | T], Acc, Length, Special) when ?is_upcase(H); ?is_downcase(H); ?is_digit(H); H =:= $_ -> + tokenize_continue(T, [H | Acc], Length + 1, Special); +tokenize_continue(Rest, Acc, Length, Special) -> + {Acc, Rest, Length, Special}. + +tokenize_identifier(String, Line, Column, Scope, MaybeKeyword) -> + case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(String) of + {Kind, Acc, Rest, Length, Ascii, Special} -> + Keyword = MaybeKeyword andalso maybe_keyword(Rest), + + case keyword_or_unsafe_to_atom(Keyword, Acc, Line, Column, Scope) of + {keyword, Atom, Type} -> + {keyword, Atom, Type, Rest, Length}; + {ok, Atom} -> + {Kind, Acc, Atom, Rest, Length, Ascii, Special}; + {error, _Reason} = Error -> + Error + end; + + {error, {not_highly_restrictive, Wrong, {Prefix, Suffix}}} -> + WrongColumn = Column + length(Wrong) - 1, + case suggest_simpler_unexpected_token_in_error(Wrong, Line, WrongColumn, Scope) of + no_suggestion -> + %% we append a pointer to more info if we aren't appending a suggestion + MoreInfo = "\nSee https://hexdocs.pm/elixir/unicode-syntax.html for more information.", + {error, {?LOC(Line, Column), {Prefix, Suffix ++ MoreInfo}, Wrong}}; + + {_, {Location, _, SuggestionMessage}} = _SuggestionError -> + {error, {Location, {Prefix, Suffix ++ SuggestionMessage}, Wrong}} + end; + + {error, {unexpected_token, Wrong}} -> + WrongColumn = Column + length(Wrong) - 1, + case suggest_simpler_unexpected_token_in_error(Wrong, Line, WrongColumn, Scope) of + no_suggestion -> + [T | _] = lists:reverse(Wrong), + case suggest_simpler_unexpected_token_in_error([T], Line, WrongColumn, Scope) of + no_suggestion -> {unexpected_token, length(Wrong)}; + SuggestionError -> SuggestionError + end; + + SuggestionError -> + SuggestionError + end; + + {error, empty} -> + empty + end. + +%% heuristic: try nfkc; try confusability skeleton; try calling this again w/just failed codepoint +suggest_simpler_unexpected_token_in_error(Wrong, Line, WrongColumn, Scope) -> + NFKC = unicode:characters_to_nfkc_list(Wrong), + case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(NFKC) of + {error, _Reason} -> + ConfusableSkeleton = 'Elixir.String.Tokenizer.Security':confusable_skeleton(Wrong), + case (Scope#elixir_tokenizer.identifier_tokenizer):tokenize(ConfusableSkeleton) of + {_, Simpler, _, _, _, _} -> + Message = suggest_change("Codepoint failed identifier tokenization, but a simpler form was found.", + Wrong, + "You could write the above in a similar way that is accepted by Elixir:", + Simpler, + "See https://hexdocs.pm/elixir/unicode-syntax.html for more information."), + {error, {?LOC(Line, WrongColumn), "unexpected token: ", Message}}; + _other -> + no_suggestion + end; + {_, _NFKC, _, _, _, _} -> + Message = suggest_change("Elixir expects unquoted Unicode atoms, variables, and calls to use allowed codepoints and to be in NFC form.", + Wrong, + "You could write the above in a compatible format that is accepted by Elixir:", + NFKC, + "See https://hexdocs.pm/elixir/unicode-syntax.html for more information."), + {error, {?LOC(Line, WrongColumn), "unexpected token: ", Message}} + end. + +suggest_change(Intro, WrongForm, Hint, HintedForm, Ending) -> + WrongCodepoints = list_to_codepoint_hex(WrongForm), + HintedCodepoints = list_to_codepoint_hex(HintedForm), + io_lib:format("~ts\n\nGot:\n\n \"~ts\" (code points~ts)\n\n" + "Hint: ~ts\n\n \"~ts\" (code points~ts)\n\n~ts", + [Intro, WrongForm, WrongCodepoints, Hint, HintedForm, HintedCodepoints, Ending]). + +maybe_keyword([]) -> true; +maybe_keyword([$:, $: | _]) -> true; +maybe_keyword([$: | _]) -> false; +maybe_keyword(_) -> true. + +list_to_codepoint_hex(List) -> + [io_lib:format(" 0x~5.16.0B", [Codepoint]) || Codepoint <- List]. + +tokenize_alias(Rest, Line, Column, Unencoded, Atom, Length, Ascii, Special, Scope, Tokens) -> + if + not Ascii or (Special /= []) -> + Invalid = hd([C || C <- Unencoded, (C < $A) or (C > 127)]), + Reason = {?LOC(Line, Column), invalid_character_error("alias (only ASCII characters, without punctuation, are allowed)", Invalid), Unencoded}, + error(Reason, Unencoded ++ Rest, Scope, Tokens); + + true -> + AliasesToken = {alias, {Line, Column, Unencoded}, Atom}, + tokenize(Rest, Line, Column + Length, Scope, [AliasesToken | Tokens]) + end. + +%% Check if it is a call identifier (paren | bracket | do) + +check_call_identifier(Line, Column, Unencoded, Atom, [$( | _]) -> + {paren_identifier, {Line, Column, Unencoded}, Atom}; +check_call_identifier(Line, Column, Unencoded, Atom, [$[ | _]) -> + {bracket_identifier, {Line, Column, Unencoded}, Atom}; +check_call_identifier(Line, Column, Unencoded, Atom, _Rest) -> + {identifier, {Line, Column, Unencoded}, Atom}. + +add_token_with_eol({unary_op, _, _} = Left, T) -> [Left | T]; +add_token_with_eol(Left, [{eol, _} | T]) -> [Left | T]; +add_token_with_eol(Left, T) -> [Left | T]. + +previous_was_eol([{',', {_, _, Count}} | _]) when Count > 0 -> Count; +previous_was_eol([{';', {_, _, Count}} | _]) when Count > 0 -> Count; +previous_was_eol([{eol, {_, _, Count}} | _]) when Count > 0 -> Count; +previous_was_eol(_) -> nil. + +%% Error handling + +interpolation_error(Reason, Rest, Scope, Tokens, Extension, Args, Line, Column, Opening, Closing) -> + error(interpolation_format(Reason, Extension, Args, Line, Column, Opening, Closing), Rest, Scope, Tokens). + +interpolation_format({string, EndLine, EndColumn, Message, Token}, Extension, Args, Line, Column, Opening, Closing) -> + Meta = [ + {opening_delimiter, list_to_atom(Opening)}, + {expected_delimiter, list_to_atom(Closing)}, + {line, Line}, + {column, Column}, + {end_line, EndLine}, + {end_column, EndColumn} + ], + {Meta, [Message, io_lib:format(Extension, Args)], Token}; +interpolation_format({_, _, _} = Reason, _Extension, _Args, _Line, _Column, _Opening, _Closing) -> + Reason. + +%% Terminators + +handle_terminator(Rest, _, _, Scope, {'(', {Line, Column, _}}, [{alias, _, Alias} | Tokens]) -> + Reason = + io_lib:format( + "unexpected ( after alias ~ts. Function names and identifiers in Elixir " + "start with lowercase characters or underscore. For example:\n\n" + " hello_world()\n" + " _starting_with_underscore()\n" + " numb3rs_are_allowed()\n" + " may_finish_with_question_mark?()\n" + " may_finish_with_exclamation_mark!()\n\n" + "Unexpected token: ", + [Alias] + ), + + error({?LOC(Line, Column), Reason, ["("]}, atom_to_list(Alias) ++ [$( | Rest], Scope, Tokens); +handle_terminator(Rest, Line, Column, #elixir_tokenizer{terminators=none} = Scope, Token, Tokens) -> + tokenize(Rest, Line, Column, Scope, [Token | Tokens]); +handle_terminator(Rest, Line, Column, Scope, Token, Tokens) -> + #elixir_tokenizer{terminators=Terminators} = Scope, + + case check_terminator(Token, Terminators, Scope) of + {error, Reason} -> + error(Reason, atom_to_list(element(1, Token)) ++ Rest, Scope, Tokens); + {ok, New} -> + tokenize(Rest, Line, Column, New, [Token | Tokens]) + end. + +check_terminator({Start, Meta}, Terminators, Scope) + when Start == '('; Start == '['; Start == '{'; Start == '<<' -> + Indentation = Scope#elixir_tokenizer.indentation, + {ok, Scope#elixir_tokenizer{terminators=[{Start, Meta, Indentation} | Terminators]}}; + +check_terminator({Start, Meta}, Terminators, Scope) when Start == 'fn'; Start == 'do' -> + Indentation = Scope#elixir_tokenizer.indentation, + + NewScope = + case Terminators of + %% If the do is indented equally or less than the previous do, it may be a missing end error! + [{Start, _, PreviousIndentation} = Previous | _] when Indentation =< PreviousIndentation -> + Scope#elixir_tokenizer{mismatch_hints=[Previous | Scope#elixir_tokenizer.mismatch_hints]}; + + _ -> + Scope + end, + + {ok, NewScope#elixir_tokenizer{terminators=[{Start, Meta, Indentation} | Terminators]}}; + +check_terminator({'end', {EndLine, _, _}}, [{'do', _, Indentation} | Terminators], Scope) -> + NewScope = + %% If the end is more indented than the do, it may be a missing do error! + case Scope#elixir_tokenizer.indentation > Indentation of + true -> + Hint = {'end', EndLine, Scope#elixir_tokenizer.indentation}, + Scope#elixir_tokenizer{mismatch_hints=[Hint | Scope#elixir_tokenizer.mismatch_hints]}; + + false -> + Scope + end, + + {ok, NewScope#elixir_tokenizer{terminators=Terminators}}; + +check_terminator({End, {EndLine, EndColumn, _}}, [{Start, {StartLine, StartColumn, _}, _} | Terminators], Scope) + when End == 'end'; End == ')'; End == ']'; End == '}'; End == '>>' -> + case terminator(Start) of + End -> + {ok, Scope#elixir_tokenizer{terminators=Terminators}}; + + ExpectedEnd -> + Meta = [ + {line, StartLine}, + {column, StartColumn}, + {end_line, EndLine}, + {end_column, EndColumn}, + {error_type, mismatched_delimiter}, + {opening_delimiter, Start}, + {closing_delimiter, End}, + {expected_delimiter, ExpectedEnd} + ], + {error, {Meta, unexpected_token_or_reserved(End), [atom_to_list(End)]}} + end; + +check_terminator({'end', {Line, Column, _}}, [], #elixir_tokenizer{mismatch_hints=Hints}) -> + Suffix = + case lists:keyfind('end', 1, Hints) of + {'end', HintLine, _Identation} -> + io_lib:format("\n~ts the \"end\" on line ~B may not have a matching \"do\" " + "defined before it (based on indentation)", [future_elixir_errors:prefix(hint), HintLine]); + false -> + "" + end, + + {error, {?LOC(Line, Column), {"unexpected reserved word: ", Suffix}, "end"}}; + +check_terminator({End, {Line, Column, _}}, [], _Scope) + when End == ')'; End == ']'; End == '}'; End == '>>' -> + {error, {?LOC(Line, Column), "unexpected token: ", atom_to_list(End)}}; + +check_terminator(_, _, Scope) -> + {ok, Scope}. + +unexpected_token_or_reserved('end') -> "unexpected reserved word: "; +unexpected_token_or_reserved(_) -> "unexpected token: ". + +missing_terminator_hint(Start, End, #elixir_tokenizer{mismatch_hints=Hints}) -> + case lists:keyfind(Start, 1, Hints) of + {Start, {HintLine, _, _}, _} -> + io_lib:format("\n~ts it looks like the \"~ts\" on line ~B does not have a matching \"~ts\"", + [future_elixir_errors:prefix(hint), Start, HintLine, End]); + false -> + "" + end. + +string_type($") -> bin_string; +string_type($') -> list_string. + +heredoc_type($") -> bin_heredoc; +heredoc_type($') -> list_heredoc. + +sigil_terminator($() -> $); +sigil_terminator($[) -> $]; +sigil_terminator(${) -> $}; +sigil_terminator($<) -> $>; +sigil_terminator(O) -> O. + +terminator('fn') -> 'end'; +terminator('do') -> 'end'; +terminator('(') -> ')'; +terminator('[') -> ']'; +terminator('{') -> '}'; +terminator('<<') -> '>>'. + +%% Keywords checking + +keyword_or_unsafe_to_atom(true, "fn", _Line, _Column, _Scope) -> {keyword, 'fn', terminator}; +keyword_or_unsafe_to_atom(true, "do", _Line, _Column, _Scope) -> {keyword, 'do', terminator}; +keyword_or_unsafe_to_atom(true, "end", _Line, _Column, _Scope) -> {keyword, 'end', terminator}; +keyword_or_unsafe_to_atom(true, "true", _Line, _Column, _Scope) -> {keyword, 'true', token}; +keyword_or_unsafe_to_atom(true, "false", _Line, _Column, _Scope) -> {keyword, 'false', token}; +keyword_or_unsafe_to_atom(true, "nil", _Line, _Column, _Scope) -> {keyword, 'nil', token}; + +keyword_or_unsafe_to_atom(true, "not", _Line, _Column, _Scope) -> {keyword, 'not', unary_op}; +keyword_or_unsafe_to_atom(true, "and", _Line, _Column, _Scope) -> {keyword, 'and', and_op}; +keyword_or_unsafe_to_atom(true, "or", _Line, _Column, _Scope) -> {keyword, 'or', or_op}; +keyword_or_unsafe_to_atom(true, "when", _Line, _Column, _Scope) -> {keyword, 'when', when_op}; +keyword_or_unsafe_to_atom(true, "in", _Line, _Column, _Scope) -> {keyword, 'in', in_op}; + +keyword_or_unsafe_to_atom(true, "after", _Line, _Column, _Scope) -> {keyword, 'after', block}; +keyword_or_unsafe_to_atom(true, "else", _Line, _Column, _Scope) -> {keyword, 'else', block}; +keyword_or_unsafe_to_atom(true, "catch", _Line, _Column, _Scope) -> {keyword, 'catch', block}; +keyword_or_unsafe_to_atom(true, "rescue", _Line, _Column, _Scope) -> {keyword, 'rescue', block}; + +keyword_or_unsafe_to_atom(_, Part, Line, Column, Scope) -> + unsafe_to_atom(Part, Line, Column, Scope). + +tokenize_keyword(terminator, Rest, Line, Column, Atom, Length, Scope, Tokens) -> + case tokenize_keyword_terminator(Line, Column, Atom, Tokens) of + {ok, [Check | T]} -> + handle_terminator(Rest, Line, Column + Length, Scope, Check, T); + {error, Message, Token} -> + error({?LOC(Line, Column), Message, Token}, Token ++ Rest, Scope, Tokens) + end; + +tokenize_keyword(token, Rest, Line, Column, Atom, Length, Scope, Tokens) -> + Token = {Atom, {Line, Column, nil}}, + tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]); + +tokenize_keyword(block, Rest, Line, Column, Atom, Length, Scope, Tokens) -> + Token = {block_identifier, {Line, Column, nil}, Atom}, + tokenize(Rest, Line, Column + Length, Scope, [Token | Tokens]); + +tokenize_keyword(Kind, Rest, Line, Column, Atom, Length, Scope, Tokens) -> + NewTokens = + case strip_horizontal_space(Rest, 0) of + {[$/ | _], _} -> + [{identifier, {Line, Column, nil}, Atom} | Tokens]; + + _ -> + case {Kind, Tokens} of + {in_op, [{unary_op, NotInfo, 'not'} | T]} -> + add_token_with_eol({in_op, NotInfo, 'not in'}, T); + + {_, _} -> + add_token_with_eol({Kind, {Line, Column, previous_was_eol(Tokens)}, Atom}, Tokens) + end + end, + + tokenize(Rest, Line, Column + Length, Scope, NewTokens). + +tokenize_sigil([$~ | T], Line, Column, Scope, Tokens) -> + case tokenize_sigil_name(T, [], Line, Column + 1, Scope, Tokens) of + {ok, Name, Rest, NewLine, NewColumn, NewScope, NewTokens} -> + tokenize_sigil_contents(Rest, Name, NewLine, NewColumn, NewScope, NewTokens); + + {error, Message, Token} -> + Reason = {?LOC(Line, Column), Message, Token}, + error(Reason, T, Scope, Tokens) + end. + +% A one-letter sigil is ok both as upcase as well as downcase. +tokenize_sigil_name([S | T], [], Line, Column, Scope, Tokens) when ?is_upcase(S) orelse ?is_downcase(S) -> + tokenize_sigil_name(T, [S], Line, Column + 1, Scope, Tokens); +% If we have an uppercase letter, we keep tokenizing the name. +tokenize_sigil_name([S | T], NameAcc, Line, Column, Scope, Tokens) when ?is_upcase(S) -> + tokenize_sigil_name(T, [S | NameAcc], Line, Column + 1, Scope, Tokens); +% With a lowercase letter and a non-empty NameAcc we return an error. +tokenize_sigil_name([S | _T] = Original, [_ | _] = NameAcc, _Line, _Column, _Scope, _Tokens) when ?is_downcase(S) -> + Message = "invalid sigil name, it should be either a one-letter lowercase letter or a" ++ + " sequence of uppercase letters only, got: ", + {error, Message, [$~] ++ lists:reverse(NameAcc) ++ Original}; +% We finished the letters, so the name is over. +tokenize_sigil_name(T, NameAcc, Line, Column, Scope, Tokens) -> + {ok, lists:reverse(NameAcc), T, Line, Column, Scope, Tokens}. + +tokenize_sigil_contents([H, H, H | T] = Original, [S | _] = SigilName, Line, Column, Scope, Tokens) + when ?is_quote(H) -> + case extract_heredoc_with_interpolation(Line, Column, Scope, ?is_downcase(S), T, H) of + {ok, NewLine, NewColumn, Parts, Rest, NewScope} -> + Indentation = NewColumn - 4, + add_sigil_token(SigilName, Line, Column, NewLine, NewColumn, Parts, Rest, NewScope, Tokens, Indentation, <>); + + {error, Reason} -> + error(Reason, [$~] ++ SigilName ++ Original, Scope, Tokens) + end; + +tokenize_sigil_contents([H | T] = Original, [S | _] = SigilName, Line, Column, Scope, Tokens) + when ?is_sigil(H) -> + case future_elixir_interpolation:extract(Line, Column + 1, Scope, ?is_downcase(S), T, sigil_terminator(H)) of + {NewLine, NewColumn, Parts, Rest, NewScope} -> + Indentation = nil, + add_sigil_token(SigilName, Line, Column, NewLine, NewColumn, tokens_to_binary(Parts), Rest, NewScope, Tokens, Indentation, <>); + + {error, Reason} -> + Sigil = [$~, S, H], + Message = " (for sigil ~ts starting at line ~B)", + interpolation_error(Reason, [$~] ++ SigilName ++ Original, Scope, Tokens, Message, [Sigil, Line], Line, Column, [H], [sigil_terminator(H)]) + end; + +tokenize_sigil_contents([H | _] = Original, SigilName, Line, Column, Scope, Tokens) -> + MessageString = + "\"~ts\" (column ~p, code point U+~4.16.0B). The available delimiters are: " + "//, ||, \"\", '', (), [], {}, <>", + Message = io_lib:format(MessageString, [[H], Column, H]), + ErrorColumn = Column - 1 - length(SigilName), + error({?LOC(Line, ErrorColumn), "invalid sigil delimiter: ", Message}, [$~] ++ SigilName ++ Original, Scope, Tokens); + +% Incomplete sigil. +tokenize_sigil_contents([], _SigilName, Line, Column, Scope, Tokens) -> + tokenize([], Line, Column, Scope, Tokens). + +add_sigil_token(SigilName, Line, Column, NewLine, NewColumn, Parts, Rest, Scope, Tokens, Indentation, Delimiter) -> + TokenColumn = Column - 1 - length(SigilName), + MaybeEncoded = case SigilName of + % Single-letter sigils present no risk of atom exhaustion (limited possibilities) + [_Char] -> {ok, list_to_atom("sigil_" ++ SigilName)}; + _ -> unsafe_to_atom("sigil_" ++ SigilName, Line, TokenColumn, Scope) + end, + case MaybeEncoded of + {ok, Atom} -> + {Final, Modifiers} = collect_modifiers(Rest, []), + Token = {sigil, {Line, TokenColumn, nil}, Atom, Parts, Modifiers, Indentation, Delimiter}, + NewColumnWithModifiers = NewColumn + length(Modifiers), + tokenize(Final, NewLine, NewColumnWithModifiers, Scope, [Token | Tokens]); + + {error, Reason} -> + error(Reason, Rest, Scope, Tokens) + end. + +%% Fail early on invalid do syntax. For example, after +%% most keywords, after comma and so on. +tokenize_keyword_terminator(DoLine, DoColumn, do, [{identifier, {Line, Column, Meta}, Atom} | T]) -> + {ok, add_token_with_eol({do, {DoLine, DoColumn, nil}}, + [{do_identifier, {Line, Column, Meta}, Atom} | T])}; +tokenize_keyword_terminator(_Line, _Column, do, [{'fn', _} | _]) -> + {error, invalid_do_with_fn_error("unexpected reserved word: "), "do"}; +tokenize_keyword_terminator(Line, Column, do, Tokens) -> + case is_valid_do(Tokens) of + true -> {ok, add_token_with_eol({do, {Line, Column, nil}}, Tokens)}; + false -> {error, invalid_do_error("unexpected reserved word: "), "do"} + end; +tokenize_keyword_terminator(Line, Column, Atom, Tokens) -> + {ok, [{Atom, {Line, Column, nil}} | Tokens]}. + +is_valid_do([{Atom, _} | _]) -> + case Atom of + ',' -> false; + ';' -> false; + 'not' -> false; + 'and' -> false; + 'or' -> false; + 'when' -> false; + 'in' -> false; + 'after' -> false; + 'else' -> false; + 'catch' -> false; + 'rescue' -> false; + _ -> true + end; +is_valid_do(_) -> + true. + +invalid_character_error(What, Char) -> + io_lib:format("invalid character \"~ts\" (code point U+~4.16.0B) in ~ts: ", [[Char], Char, What]). + +invalid_do_error(Prefix) -> + {Prefix, ". In case you wanted to write a \"do\" expression, " + "you must either use do-blocks or separate the keyword argument with comma. " + "For example, you should either write:\n\n" + " if some_condition? do\n" + " :this\n" + " else\n" + " :that\n" + " end\n\n" + "or the equivalent construct:\n\n" + " if(some_condition?, do: :this, else: :that)\n\n" + "where \"some_condition?\" is the first argument and the second argument is a keyword list.\n\n" + "You may see this error if you forget a trailing comma before the \"do\" in a \"do\" block"}. + +invalid_do_with_fn_error(Prefix) -> + {Prefix, ". Anonymous functions are written as:\n\n" + " fn pattern -> expression end\n\nPlease remove the \"do\" keyword"}. + +% TODO: Turn into an error on v2.0 +maybe_warn_too_many_of_same_char([T | _] = Token, [T | _] = _Rest, Line, Column, Scope) -> + Message = io_lib:format( + "found \"~ts\" followed by \"~ts\", please use a space between \"~ts\" and the next \"~ts\"", + [Token, [T], Token, [T]] + ), + prepend_warning(Line, Column, Message, Scope); +maybe_warn_too_many_of_same_char(_Token, _Rest, _Line, _Column, Scope) -> + Scope. + +%% TODO: Turn into an error on v2.0 +maybe_warn_for_ambiguous_bang_before_equals(Kind, Unencoded, [$= | _], Line, Column, Scope) -> + {What, Identifier} = + case Kind of + atom -> {"atom", [$: | Unencoded]}; + identifier -> {"identifier", Unencoded} + end, + + case lists:last(Identifier) of + Last when Last =:= $!; Last =:= $? -> + Msg = io_lib:format("found ~ts \"~ts\", ending with \"~ts\", followed by =. " + "It is unclear if you mean \"~ts ~ts=\" or \"~ts =\". Please add " + "a space before or after ~ts to remove the ambiguity", + [What, Identifier, [Last], lists:droplast(Identifier), [Last], Identifier, [Last]]), + prepend_warning(Line, Column, Msg, Scope); + _ -> + Scope + end; +maybe_warn_for_ambiguous_bang_before_equals(_Kind, _Atom, _Rest, _Line, _Column, Scope) -> + Scope. + +prepend_warning(Line, Column, Msg, #elixir_tokenizer{warnings=Warnings} = Scope) -> + Scope#elixir_tokenizer{warnings = [{{Line, Column}, Msg} | Warnings]}. + +track_ascii(true, Scope) -> Scope; +track_ascii(false, Scope) -> Scope#elixir_tokenizer{ascii_identifiers_only=false}. + +maybe_unicode_lint_warnings(_Ascii=false, Tokens, Warnings) -> + 'Elixir.String.Tokenizer.Security':unicode_lint_warnings(lists:reverse(Tokens)) ++ Warnings; +maybe_unicode_lint_warnings(_Ascii=true, _Tokens, Warnings) -> + Warnings. + +error(Reason, Rest, #elixir_tokenizer{warnings=Warnings}, Tokens) -> + {error, Reason, Rest, Warnings, Tokens}. + +%% Cursor handling + +cursor_complete(Line, Column, Terminators) -> + lists:mapfoldl( + fun({Start, _, _}, AccColumn) -> + End = terminator(Start), + {{End, {Line, AccColumn, nil}}, AccColumn + length(erlang:atom_to_list(End))} + end, + Column, + Terminators + ). + +add_cursor(_Line, Column, noprune, Terminators, Tokens) -> + {Column, Terminators, Tokens}; +add_cursor(Line, Column, prune_and_cursor, Terminators, Tokens) -> + PrePrunedTokens = prune_identifier(Tokens), + {PrunedTokens, PrunedTerminators} = prune_tokens(PrePrunedTokens, [], Terminators), + CursorTokens = [ + {')', {Line, Column + 11, nil}}, + {'(', {Line, Column + 10, nil}}, + {paren_identifier, {Line, Column, nil}, '__cursor__'} + | PrunedTokens + ], + {Column + 12, PrunedTerminators, CursorTokens}. + +prune_identifier([{identifier, _, _} | Tokens]) -> Tokens; +prune_identifier(Tokens) -> Tokens. + +%%% Any terminator needs to be closed +prune_tokens([{'end', _} | Tokens], Opener, Terminators) -> + prune_tokens(Tokens, ['end' | Opener], Terminators); +prune_tokens([{')', _} | Tokens], Opener, Terminators) -> + prune_tokens(Tokens, [')' | Opener], Terminators); +prune_tokens([{']', _} | Tokens], Opener, Terminators) -> + prune_tokens(Tokens, [']' | Opener], Terminators); +prune_tokens([{'}', _} | Tokens], Opener, Terminators) -> + prune_tokens(Tokens, ['}' | Opener], Terminators); +prune_tokens([{'>>', _} | Tokens], Opener, Terminators) -> + prune_tokens(Tokens, ['>>' | Opener], Terminators); +%%% Close opened terminators +prune_tokens([{'fn', _} | Tokens], ['end' | Opener], Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +prune_tokens([{'do', _} | Tokens], ['end' | Opener], Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +prune_tokens([{'(', _} | Tokens], [')' | Opener], Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +prune_tokens([{'[', _} | Tokens], [']' | Opener], Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +prune_tokens([{'{', _} | Tokens], ['}' | Opener], Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +prune_tokens([{'<<', _} | Tokens], ['>>' | Opener], Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +%%% Handle anonymous functions +prune_tokens([{'(', _}, {capture_op, _, _} | Tokens], [], [{'(', _, _} | Terminators]) -> + prune_tokens(Tokens, [], Terminators); +%%% or it is time to stop... +prune_tokens([{';', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'eol', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{',', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'fn', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'do', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'(', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'[', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'{', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{'<<', _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{identifier, _, _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{block_identifier, _, _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{kw_identifier, _, _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{kw_identifier_safe, _, _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{kw_identifier_unsafe, _, _} | _] = Tokens, [], Terminators) -> + {Tokens, Terminators}; +prune_tokens([{OpType, _, _} | _] = Tokens, [], Terminators) + when OpType =:= comp_op; OpType =:= at_op; OpType =:= unary_op; OpType =:= and_op; + OpType =:= or_op; OpType =:= arrow_op; OpType =:= match_op; OpType =:= in_op; + OpType =:= in_match_op; OpType =:= type_op; OpType =:= dual_op; OpType =:= mult_op; + OpType =:= power_op; OpType =:= concat_op; OpType =:= range_op; OpType =:= xor_op; + OpType =:= pipe_op; OpType =:= stab_op; OpType =:= when_op; OpType =:= assoc_op; + OpType =:= rel_op; OpType =:= ternary_op; OpType =:= capture_op; OpType =:= ellipsis_op -> + {Tokens, Terminators}; +%%% or we traverse until the end. +prune_tokens([_ | Tokens], Opener, Terminators) -> + prune_tokens(Tokens, Opener, Terminators); +prune_tokens([], [], Terminators) -> + {[], Terminators}. diff --git a/forge/src/future_elixir_tokenizer.hrl b/forge/src/future_elixir_tokenizer.hrl new file mode 100644 index 00000000..00caf183 --- /dev/null +++ b/forge/src/future_elixir_tokenizer.hrl @@ -0,0 +1,34 @@ +%% Copied from https://github.com/elixir-lang/elixir/blob/d7ea2fa2e4e5de1990297be19495fc93740b2e8b/lib/elixir/src/elixir_tokenizer.hrl +%% Numbers +-define(is_hex(S), (?is_digit(S) orelse (S >= $A andalso S =< $F) orelse (S >= $a andalso S =< $f))). +-define(is_bin(S), (S >= $0 andalso S =< $1)). +-define(is_octal(S), (S >= $0 andalso S =< $7)). + +%% Digits and letters +-define(is_digit(S), (S >= $0 andalso S =< $9)). +-define(is_upcase(S), (S >= $A andalso S =< $Z)). +-define(is_downcase(S), (S >= $a andalso S =< $z)). + +%% Others +-define(is_quote(S), (S =:= $" orelse S =:= $')). +-define(is_sigil(S), (S =:= $/ orelse S =:= $< orelse S =:= $" orelse S =:= $' orelse + S =:= $[ orelse S =:= $( orelse S =:= ${ orelse S =:= $|)). +-define(LOC(Line, Column), [{line, Line}, {column, Column}]). + +%% Spaces +-define(is_horizontal_space(S), (S =:= $\s orelse S =:= $\t)). +-define(is_vertical_space(S), (S =:= $\r orelse S =:= $\n)). +-define(is_space(S), (?is_horizontal_space(S) orelse ?is_vertical_space(S))). + +%% Bidirectional control +%% Retrieved from https://trojansource.codes/trojan-source.pdf +-define(bidi(C), C =:= 16#202A; + C =:= 16#202B; + C =:= 16#202D; + C =:= 16#202E; + C =:= 16#2066; + C =:= 16#2067; + C =:= 16#2068; + C =:= 16#202C; + C =:= 16#2069). + diff --git a/forge/test/lexical/ast/detection/alias_test.exs b/forge/test/lexical/ast/detection/alias_test.exs new file mode 100644 index 00000000..3dba4142 --- /dev/null +++ b/forge/test/lexical/ast/detection/alias_test.exs @@ -0,0 +1,7 @@ +defmodule Forge.Ast.Detection.AliasTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Alias, + assertions: [[:alias, :*]] +end diff --git a/forge/test/lexical/ast/detection/bitstring_test.exs b/forge/test/lexical/ast/detection/bitstring_test.exs new file mode 100644 index 00000000..0f2ab329 --- /dev/null +++ b/forge/test/lexical/ast/detection/bitstring_test.exs @@ -0,0 +1,6 @@ +defmodule Forge.Ast.Detection.BitstringTest do + use Forge.Test.DetectionCase, + for: Forge.Ast.Detection.Bitstring, + assertions: [[:bitstring, :*]], + variations: [:match, :function_arguments, :function_body] +end diff --git a/forge/test/lexical/ast/detection/comment_test.exs b/forge/test/lexical/ast/detection/comment_test.exs new file mode 100644 index 00000000..b87b3fe2 --- /dev/null +++ b/forge/test/lexical/ast/detection/comment_test.exs @@ -0,0 +1,7 @@ +defmodule Forge.Ast.Detection.CommentTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Comment, + assertions: [[:comment, :*]] +end diff --git a/forge/test/lexical/ast/detection/function_capture_test.exs b/forge/test/lexical/ast/detection/function_capture_test.exs new file mode 100644 index 00000000..e8acedfd --- /dev/null +++ b/forge/test/lexical/ast/detection/function_capture_test.exs @@ -0,0 +1,32 @@ +defmodule Forge.Ast.Detection.FunctionCaptureTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.FunctionCapture, + assertions: [[:function_capture, :*]], + variations: [:match, :function_body] + + test "detected if the capture is inside an unformatted function call" do + assert_detected ~q[list = Enum.map(1..10,&«Enum»)] + end + + test "detected if the capture is inside a function call after the dot" do + assert_detected ~q[list = Enum.map(1..10, &«Enum.f»)] + end + + test "detected if the capture is in the body of a for" do + assert_detected ~q[for x <- Enum.map(1..10, &«String.»)] + end + + test "is not detected if the capture is inside an unformatted function call" do + refute_detected ~q[list = Enum.map(1..10,Enum)] + end + + test "is not detected if the capture is inside a function call after the dot" do + refute_detected ~q[list = Enum.map(1..10, Enum.f)] + end + + test "is not detected if the capture is in the body of a for" do + refute_detected ~q[for x <- Enum.map(1..10, String.)] + end +end diff --git a/forge/test/lexical/ast/detection/import_test.exs b/forge/test/lexical/ast/detection/import_test.exs new file mode 100644 index 00000000..c74702b8 --- /dev/null +++ b/forge/test/lexical/ast/detection/import_test.exs @@ -0,0 +1,16 @@ +defmodule Forge.Ast.Detection.ImportTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Import, + assertions: [[:import, :*]] + + test "works on multi line" do + assert_detected ~q( + import« Some.Module, only: »[ + foo: 3, + bar: 6 + ] + ) + end +end diff --git a/forge/test/lexical/ast/detection/module_attribute_test.exs b/forge/test/lexical/ast/detection/module_attribute_test.exs new file mode 100644 index 00000000..fc501fc5 --- /dev/null +++ b/forge/test/lexical/ast/detection/module_attribute_test.exs @@ -0,0 +1,17 @@ +defmodule Forge.Ast.Detection.ModuleAttributeTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.ModuleAttribute, + assertions: [ + [:module_attribute, :*], + [:callbacks, :*] + ], + skip: [ + [:doc, :*], + [:module_doc, :*], + [:spec, :*], + [:type, :*] + ], + variations: [:module] +end diff --git a/forge/test/lexical/ast/detection/pipe_test.exs b/forge/test/lexical/ast/detection/pipe_test.exs new file mode 100644 index 00000000..6902d245 --- /dev/null +++ b/forge/test/lexical/ast/detection/pipe_test.exs @@ -0,0 +1,13 @@ +defmodule Forge.Ast.Detection.PipeTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Pipe, + assertions: [[:pipe, :*]], + variations: [:function_arguments], + skip: [[:module_attribute, :multi_line_pipe]] + + test "is false if there is no pipe in the string" do + refute_detected ~q[Enum.foo] + end +end diff --git a/forge/test/lexical/ast/detection/require_test.exs b/forge/test/lexical/ast/detection/require_test.exs new file mode 100644 index 00000000..12a58388 --- /dev/null +++ b/forge/test/lexical/ast/detection/require_test.exs @@ -0,0 +1,7 @@ +defmodule Forge.Ast.Detection.RequireTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Require, + assertions: [[:require, :*]] +end diff --git a/forge/test/lexical/ast/detection/spec_test.exs b/forge/test/lexical/ast/detection/spec_test.exs new file mode 100644 index 00000000..c281d1bf --- /dev/null +++ b/forge/test/lexical/ast/detection/spec_test.exs @@ -0,0 +1,7 @@ +defmodule Forge.Ast.Detection.SpecTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Spec, + assertions: [[:spec, :*]] +end diff --git a/forge/test/lexical/ast/detection/string_test.exs b/forge/test/lexical/ast/detection/string_test.exs new file mode 100644 index 00000000..12dba947 --- /dev/null +++ b/forge/test/lexical/ast/detection/string_test.exs @@ -0,0 +1,25 @@ +defmodule Forge.Ast.Detection.StringTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.String, + assertions: [[:strings, :*]], + # we skip other tests that have strings in them + skip: [ + [:doc, :*], + [:keyword, :single_line], + [:keyword, :multi_line], + [:module_doc, :*] + ], + variations: [ + :function_arguments, + :function_body, + :function_call, + :match, + :module + ] + + test "is detected if a string is keyword values" do + assert_detected ~q/def func(string: "v«alue»", atom: :value2, int: 6, float: 2.0, list: [1, 2], tuple: {3, 4}) do/ + end +end diff --git a/forge/test/lexical/ast/detection/struct_field_key_test.exs b/forge/test/lexical/ast/detection/struct_field_key_test.exs new file mode 100644 index 00000000..fd19d676 --- /dev/null +++ b/forge/test/lexical/ast/detection/struct_field_key_test.exs @@ -0,0 +1,17 @@ +defmodule Forge.Ast.Detection.StructFieldKeyTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.StructFieldKey, + assertions: [[:struct_field_key, :*]], + skip: [ + [:struct_fields, :*], + [:struct_reference, :*], + [:struct_field_value, :*] + ], + variations: [:module] + + test "is detected if a key is partially typed" do + assert_detected ~q[%User{«fo»}] + end +end diff --git a/forge/test/lexical/ast/detection/struct_field_value_test.exs b/forge/test/lexical/ast/detection/struct_field_value_test.exs new file mode 100644 index 00000000..07b24221 --- /dev/null +++ b/forge/test/lexical/ast/detection/struct_field_value_test.exs @@ -0,0 +1,25 @@ +defmodule Forge.Ast.Detection.StructFieldValueTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.StructFieldValue, + assertions: [[:struct_field_value, :*]], + skip: [ + [:struct_fields, :*], + [:struct_reference, :*], + [:struct_field_key, :*] + ], + variations: [:module] + + test "is detected directly after the colon" do + assert_detected ~q[%User{foo: «»}] + end + + test "is not detected if the cursor is a multiple line definition in a key position" do + assert_detected ~q[ + %User{ + foo: «1,» + } + ] + end +end diff --git a/forge/test/lexical/ast/detection/struct_fields_test.exs b/forge/test/lexical/ast/detection/struct_fields_test.exs new file mode 100644 index 00000000..477144cc --- /dev/null +++ b/forge/test/lexical/ast/detection/struct_fields_test.exs @@ -0,0 +1,33 @@ +defmodule Forge.Ast.Detection.StructFieldsTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.StructFields, + assertions: [[:struct_fields, :*]], + variations: [:match, :function_body, :function_arguments, :module], + skip: [ + [:struct_reference, :*], + [:struct_field_value, :*], + [:struct_field_key, :*] + ] + + test "is true if the cursor is in current module arguments" do + assert_detected ~q[%__MODULE__{«»}] + end + + test "is true even if the value of a struct key is a tuple" do + assert_detected ~q[%User{«favorite_numbers: {3}»}] + end + + test "is true even if the cursor is at a nested struct" do + assert_detected ~q[%User{«address: %Address{}»] + end + + test "is detected if it spans multiple lines" do + assert_detected ~q[ + %User{ + «name: "John", + »} + ] + end +end diff --git a/forge/test/lexical/ast/detection/struct_reference_test.exs b/forge/test/lexical/ast/detection/struct_reference_test.exs new file mode 100644 index 00000000..90232d47 --- /dev/null +++ b/forge/test/lexical/ast/detection/struct_reference_test.exs @@ -0,0 +1,45 @@ +defmodule Forge.Ast.Detection.StructReferenceTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.StructReference, + assertions: [[:struct_reference, :*]], + skip: [[:struct_fields, :*], [:struct_field_value, :*], [:struct_field_key, :*]], + variations: [:match, :function_arguments] + + test "is detected if a module reference starts in function arguments" do + assert_detected ~q[def my_function(%_«»)] + end + + test "is detected if a module reference start in a t type spec" do + assert_detected ~q[@type t :: %_«»] + end + + test "is detected if the reference is for %__MOD in a function definition " do + assert_detected ~q[def my_fn(%_«_MOD»] + end + + test "is detected if the reference is on the right side of a match" do + assert_detected ~q[foo = %U«se»] + end + + test "is detected if the reference is on the left side of a match" do + assert_detected ~q[ %U«se» = foo] + end + + test "is detected if the reference is for %__} " do + assert_detected ~q[%__] + end + + test "is not detected if the reference is for %__MOC in a function definition" do + refute_detected ~q[def my_fn(%__MOC)] + end + + test "is detected if module reference starts with %" do + assert_detected ~q[def something(my_thing, %S«truct»{})] + end + + test "is not detected if a module reference lacks a %" do + refute_detected ~q[def my_function(__)] + end +end diff --git a/forge/test/lexical/ast/detection/type_test.exs b/forge/test/lexical/ast/detection/type_test.exs new file mode 100644 index 00000000..c8403bf8 --- /dev/null +++ b/forge/test/lexical/ast/detection/type_test.exs @@ -0,0 +1,18 @@ +defmodule Forge.Ast.Detection.TypeTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Type, + assertions: [[:type, :*]] + + test "is not detected if you're in a variable named type" do + refute_detected ~q[type = 3] + end + + test "is not detected right after the type ends" do + refute_detected ~q[ + @type« my_type :: atom» + + ] + end +end diff --git a/forge/test/lexical/ast/detection/use_test.exs b/forge/test/lexical/ast/detection/use_test.exs new file mode 100644 index 00000000..b7685841 --- /dev/null +++ b/forge/test/lexical/ast/detection/use_test.exs @@ -0,0 +1,7 @@ +defmodule Forge.Ast.Detection.UseTest do + alias Forge.Ast.Detection + + use Forge.Test.DetectionCase, + for: Detection.Use, + assertions: [[:use, :*]] +end diff --git a/forge/test/lexical/ast/env_test.exs b/forge/test/lexical/ast/env_test.exs new file mode 100644 index 00000000..9e12ba0b --- /dev/null +++ b/forge/test/lexical/ast/env_test.exs @@ -0,0 +1,236 @@ +defmodule Forge.Ast.EnvTest do + use ExUnit.Case, async: true + + alias Forge.Ast + + import Forge.Ast.Env + import Forge.Test.CursorSupport + import Forge.Test.Fixtures + + def new_env(text, opts \\ []) do + opts = Keyword.merge([as: :document], opts) + project = project() + {position, document} = pop_cursor(text, opts) + analysis = Ast.analyze(document) + {:ok, env} = new(project, analysis, position) + env + end + + describe "prefix_tokens/2" do + test "works with bitstring specifiers" do + env = new_env("< new_env() + |> prefix_tokens(1) + + assert [{:float, 27.88, _}] = tokens + end + + test "works with strings" do + tokens = + ~s("hello") + |> new_env() + |> prefix_tokens(1) + + assert [{:string, "hello", _}] = tokens + end + + test "works with interpolated strings" do + tokens = + ~S("hello#{a}") + |> new_env() + |> prefix_tokens(1) + + assert [{:interpolated_string, interpolations, {1, 1}}] = tokens + + assert interpolations == [ + {:literal, "hello", {{1, 1}, {1, 6}}}, + {:interpolation, [{:identifier, {1, 9, ~c"a"}, :a}], {{1, 9}, {1, 10}}} + ] + end + + test "works with maps with atom keys" do + tokens = + "%{a: 3}" + |> new_env() + |> prefix_tokens(9) + + assert [ + {:curly, :"}", _}, + {:int, 3, _}, + {:kw_identifier, ~c"a", _}, + {:curly, :"{", _}, + {:map_new, :%{}, _} + ] = tokens + end + + test "works with maps with string keys" do + tokens = + ~s(%{"a" => 3}) + |> new_env() + |> prefix_tokens(8) + + assert [ + {:curly, :"}", _}, + {:int, 3, _}, + {:assoc_op, nil, _}, + {:string, "a", _}, + {:curly, :"{", _}, + {:map_new, :%{}, _} + ] = tokens + end + + test "works with pattern matches" do + tokens = + "my_var = 3 + 5" + |> new_env() + |> prefix_tokens(3) + + assert [ + {:int, 5, _}, + {:operator, :+, _}, + {:int, 3, _} + ] = tokens + end + + test "works with remote function calls" do + tokens = + "Enum.map|" + |> new_env() + |> prefix_tokens(9) + + assert [ + {:identifier, ~c"map", _}, + {:operator, :., _}, + {:alias, ~c"Enum", _} + ] = tokens + end + + test "works with local function calls" do + tokens = + "foo = local(|" + |> new_env() + |> prefix_tokens(9) + + assert [ + {:paren, :"(", _}, + {:paren_identifier, ~c"local", _}, + {:match_op, nil, _}, + {:identifier, ~c"foo", _} + ] = tokens + end + + test "consumes as many tokens as it can" do + tokens = + "String.tri|" + |> new_env() + |> prefix_tokens(900) + + assert [ + {:identifier, ~c"tri", _}, + {:operator, :., _}, + {:alias, ~c"String", _} + ] = tokens + end + + test "works with macros" do + tokens = + "defmacro MyModule do" + |> new_env() + |> prefix_tokens(3) + + assert [ + {:operator, :do, _}, + {:alias, ~c"MyModule", _}, + {:identifier, ~c"defmacro", _} + ] = tokens + end + + test "works with lists of integers" do + tokens = + "x = [1, 2, 3]" + |> new_env() + |> prefix_tokens(7) + + assert [ + {:operator, :"]", _}, + {:int, 3, _}, + {:comma, :",", _}, + {:int, 2, _}, + {:comma, :",", _}, + {:int, 1, _}, + {:operator, :"[", _} + ] = tokens + end + end + + describe "in_context?/2" do + test "can detect module attributes" do + env = new_env("@my_attr 3") + + assert in_context?(env, {:module_attribute, :my_attr}) + refute in_context?(env, {:module_attribute, :other}) + end + + test "can detect behaviours" do + env = new_env("@behaviour Modul|e") + + assert in_context?(env, :behaviour) + end + + test "can detect behaviour implementations" do + env = new_env("@impl GenServer|") + + assert in_context?(env, :impl) + end + + test "can detect docstrings " do + env = new_env("@doc false|") + assert in_context?(env, :doc) + + env = new_env(~S[@doc "hi"]) + assert in_context?(env, :doc) + + env = new_env(~S[@doc """ + Multi - line + """| + ]) + assert in_context?(env, :doc) + end + + test "can detect moduledocs " do + env = new_env("@moduledoc false|") + assert in_context?(env, :moduledoc) + + env = new_env(~S[@moduledoc "hi"]) + assert in_context?(env, :moduledoc) + + env = new_env(~S[@moduledoc """ + Multi - line + """| + ]) + assert in_context?(env, :moduledoc) + end + + test "can detect callbacks" do + env = new_env("@callback do_stuff|(integer(), map()) :: any()") + assert in_context?(env, :callback) + end + + test "can detect macro callbacks" do + env = new_env("@macrocallback write_code(integer(), map(|)) :: any()") + assert in_context?(env, :macrocallback) + end + + test "can detect strings" do + env = new_env(~s/var = "in |a string"/) + assert in_context?(env, :string) + end + end +end diff --git a/forge/test/lexical/ast/module_test.exs b/forge/test/lexical/ast/module_test.exs new file mode 100644 index 00000000..492eb388 --- /dev/null +++ b/forge/test/lexical/ast/module_test.exs @@ -0,0 +1,26 @@ +defmodule Forge.Ast.ModuleTest do + import Forge.Ast.Module + use ExUnit.Case, async: true + + describe "safe_split/2" do + test "splits elixir modules into binaries by default" do + assert {:elixir, ~w(Forge Document Store)} == safe_split(Forge.Document.Store) + end + + test "splits elixir modules into binaries" do + assert {:elixir, ~w(Forge Document Store)} == + safe_split(Forge.Document.Store, as: :binaries) + end + + test "splits elixir modules into atoms" do + assert {:elixir, ~w(Forge Document Store)a} == + safe_split(Forge.Document.Store, as: :atoms) + end + + test "splits erlang modules" do + assert {:erlang, ["ets"]} = safe_split(:ets) + assert {:erlang, ["ets"]} = safe_split(:ets, as: :binaries) + assert {:erlang, [:ets]} = safe_split(:ets, as: :atoms) + end + end +end diff --git a/forge/test/lexical/ast/tokens_test.exs b/forge/test/lexical/ast/tokens_test.exs new file mode 100644 index 00000000..c3f71e46 --- /dev/null +++ b/forge/test/lexical/ast/tokens_test.exs @@ -0,0 +1,51 @@ +defmodule Forge.Ast.TokensTest do + alias Forge.Ast.Tokens + + import Forge.Test.CodeSigil + import Forge.Test.CursorSupport + + use ExUnit.Case, async: true + + describe "prefix_stream/2" do + test "works as intended" do + text = ~q[ + defmodule Foo do + def bar do + | + end + end + ] + + {position, document} = pop_cursor(text, as: :document) + + tokens = Tokens.prefix_stream(document, position) + + assert Enum.to_list(tokens) == [ + {:eol, ~c"\n", []}, + {:operator, :do, {2, 11}}, + {:do_identifier, ~c"bar", {2, 7}}, + {:identifier, ~c"def", {2, 3}}, + {:eol, ~c"\n", []}, + {:operator, :do, {1, 15}}, + {:alias, ~c"Foo", {1, 11}}, + {:identifier, ~c"defmodule", {1, 1}} + ] + end + + test "returns nothing when cursor is at start" do + text = ~q[ + |defmodule Foo do + def bar do + :bar + end + end + ] + + {position, document} = pop_cursor(text, as: :document) + + tokens = Tokens.prefix_stream(document, position) + + assert Enum.to_list(tokens) == [] + end + end +end diff --git a/forge/test/lexical/ast_test.exs b/forge/test/lexical/ast_test.exs new file mode 100644 index 00000000..16796b65 --- /dev/null +++ b/forge/test/lexical/ast_test.exs @@ -0,0 +1,347 @@ +defmodule Forge.AstTest do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Document + alias Forge.Document.Position + alias Sourceror.Zipper + + import Forge.Test.CodeSigil + import Forge.Test.CursorSupport + import Forge.Test.PositionSupport + import Forge.Test.RangeSupport + + use ExUnit.Case, async: true + + describe "cursor_path/2" do + defp cursor_path(text) do + {position, document} = pop_cursor(text, as: :document) + Ast.cursor_path(document, position) + end + + test "contains the parent AST" do + text = ~q[ + defmodule Foo do + def bar do + | + end + end + ] + + path = cursor_path(text) + + assert Enum.any?(path, &match?({:def, _, _}, &1)) + assert Enum.any?(path, &match?({:defmodule, _, _}, &1)) + end + + test "returns cursor ast when is not in a container" do + text = ~q[ + | + defmodule Foo do + end + ] + + path = cursor_path(text) + assert path == [{:__cursor__, [closing: [line: 1, column: 12], line: 1, column: 1], []}] + end + + test "returns [] when can't parse the AST" do + text = ~q[ + foo(bar do baz, [bat| + ] + + path = cursor_path(text) + assert path == [] + end + end + + describe "path_at/2" do + defp path_at(text) do + {position, document} = pop_cursor(text, as: :document) + Ast.path_at(document, position) + end + + defp end_location({_, metadata, _}), do: end_location(metadata) + + defp end_location(metadata) when is_list(metadata) do + case metadata do + [line: line, column: column] -> + {line, column} + + metadata -> + [end_line: line, end_column: column] = Keyword.take(metadata, [:end_line, :end_column]) + + {line, column} + end + end + + test "returns an error if the cursor cannot be found in any node" do + code = ~q[ + | + defmodule Foo do + end + ] + + assert {:error, :not_found} = path_at(code) + end + + test "returns an error if the AST cannot be parsed" do + code = ~q[ + defmodule |Foo do + ] + + assert {:error, {metadata, "missing terminator: end" <> _, ""}} = path_at(code) + assert end_location(metadata) == {2, 1} + end + + test "returns a path to the innermost leaf at position" do + code = ~q[ + defmodule Foo do + def bar do + %{foo: |:ok} + end + end + ] + + assert {:ok, [{:__block__, _, [:ok]} | _]} = path_at(code) + end + + test "returns a path to the innermost branch at position" do + code = ~q[ + defmodule Foo do + | + end + ] + + assert {:ok, [{:defmodule, _, _}]} = path_at(code) + end + + test "returns a path containing all ancestors" do + code = ~q[ + defmodule Foo do + def |bar do + :ok + end + end + ] + + assert {:ok, + [ + {:bar, _, nil}, + {:def, _, _}, + {_, _}, + [{_, _}], + {:defmodule, _, _} + ]} = path_at(code) + end + + test "returns a path to an outer struct node" do + code = ~q[ + defmodule Foo do + |%MyStruct{} + end + ] + + assert {:ok, [{:%, _, _} | _]} = path_at(code) + end + end + + describe "traverse_line" do + setup do + text = ~q[ + line = 1 + line = 2 + line = 3 + line = 4 + "" + ]t + + document = Document.new("file:///file.ex", text, 1) + + {:ok, document: document} + end + + defp underscore_variable(%Zipper{node: {var_name, meta, nil}} = zipper) do + Zipper.replace(zipper, {:"_#{var_name}", meta, nil}) + end + + defp underscore_variable(zipper), do: zipper + + defp underscore_variable(%Zipper{node: {_var_name, _meta, nil}} = zipper, acc) do + zipper = underscore_variable(zipper) + {zipper, acc + 1} + end + + defp underscore_variable(zipper, acc), do: {zipper, acc} + + defp modify({:ok, zipper}) do + %Zipper{node: ast} = Zipper.top(zipper) + Sourceror.to_string(ast) + end + + defp modify({:ok, zipper, acc}) do + {modify({:ok, zipper}), acc} + end + + test "/3 should only affect the specified line", %{document: doc} do + converted = + doc + |> Ast.traverse_line(2, &underscore_variable/1) + |> modify() + + assert converted =~ "_line = 2" + assert converted =~ "line = 1" + assert converted =~ "line = 3" + assert converted =~ "line = 4" + end + + test "/4 should only affect the specified line, and keeps an accumulator", %{document: doc} do + {converted, acc} = + doc + |> Ast.traverse_line(2, 0, &underscore_variable/2) + |> modify() + + assert acc == 1 + assert converted =~ "_line = 2" + refute converted =~ "_line = 1" + refute converted =~ "_line = 3" + end + end + + describe "contains_position?/2 single line node" do + setup do + {range, code} = pop_range(~q| + [ + «single_line_call(1, 2, 3)» + ] + |) + + [single_line_ast] = ast(code) + + {:ok, [ast: single_line_ast, range: range]} + end + + test "at the bounds", %{ast: ast, range: range} do + assert Ast.contains_position?(ast, range.start) + assert Ast.contains_position?(ast, range.end) + end + + test "within the node", %{ast: ast, range: range} do + position = %Position{range.start | character: range.start.character + 1} + assert Ast.contains_position?(ast, position) + end + + test "outside the bounds", %{ast: ast, range: range} do + %Position{line: start_line, character: start_col} = range.start + %Position{line: end_line, character: end_col} = range.end + + refute Ast.contains_position?(ast, position(start_line, start_col - 1)) + refute Ast.contains_position?(ast, position(start_line - 1, start_col)) + refute Ast.contains_position?(ast, position(end_line, end_col + 1)) + refute Ast.contains_position?(ast, position(end_line + 1, end_col)) + end + end + + describe "contains_position?/2 multi line node" do + setup do + {range, code} = pop_range(~q| + [ + «multi_line_call( + 1, 2, 3 + )» + ] + |) + + [three_line_ast] = ast(code) + + {:ok, [ast: three_line_ast, range: range]} + end + + test "at the bounds", %{ast: ast, range: range} do + assert Ast.contains_position?(ast, range.start) + assert Ast.contains_position?(ast, range.end) + end + + test "on the first line", %{ast: ast, range: range} do + %Position{line: start_line, character: start_col} = range.start + + assert Ast.contains_position?(ast, position(start_line, start_col + 1)) + refute Ast.contains_position?(ast, position(start_line, start_col - 1)) + end + + test "on the last line", %{ast: ast, range: range} do + %Position{line: end_line, character: end_col} = range.end + + assert Ast.contains_position?(ast, position(end_line, end_col - 1)) + refute Ast.contains_position?(ast, position(end_line, end_col + 1)) + end + + test "within the lines", %{ast: ast, range: range} do + %Position{line: start_line} = range.start + + assert Ast.contains_position?(ast, position(start_line + 1, 1)) + assert Ast.contains_position?(ast, position(start_line + 1, 1_000)) + end + + test "outside the lines", %{ast: ast, range: range} do + %Position{line: start_line, character: start_col} = range.start + %Position{line: end_line, character: end_col} = range.end + + refute Ast.contains_position?(ast, position(start_line - 1, start_col)) + refute Ast.contains_position?(ast, position(end_line + 1, end_col)) + end + end + + describe "analyze/1" do + test "creates an analysis from a document with valid ast" do + code = ~q[ + defmodule Valid do + end + ] + + assert %Analysis{} = analysis = analyze(code) + assert {:defmodule, _, _} = analysis.ast + end + + test "creates an analysis from a document with invalid ast" do + code = ~q[ + defmodule Invalid do + ] + + assert %Analysis{} = analysis = analyze(code) + refute analysis.ast + assert {:error, _} = analysis.parse_error + end + + test "creates an analysis from a document with incomplete `as` section" do + code = ~q[ + defmodule Invalid do + alias Foo, a + end + ] + + assert %Analysis{} = analysis = analyze(code) + assert {:defmodule, _, _} = analysis.ast + end + + test "handles incomplete imports" do + code = ~q[ + defmodule Invalid do + import Other, only: :m + end + ] + assert %Analysis{} = analyze(code) + end + end + + defp ast(s) do + case Ast.from(s) do + {:ok, {:__block__, _, [node]}, _comments} -> node + {:ok, node, _comments} -> node + end + end + + defp analyze(code) when is_binary(code) do + document = Document.new("file:///file.ex", code, 0) + Ast.analyze(document) + end +end diff --git a/forge/test/lexical/code_unit_test.exs b/forge/test/lexical/code_unit_test.exs new file mode 100644 index 00000000..d278b3dc --- /dev/null +++ b/forge/test/lexical/code_unit_test.exs @@ -0,0 +1,77 @@ +defmodule Forge.CodeUnitTest do + alias Forge.CodeUnit + + use ExUnit.Case + + import CodeUnit + + describe "utf8_position_to_utf16_offset/2" do + test "handles single-byte characters" do + s = "do" + assert 0 == utf8_position_to_utf16_offset(s, 0) + assert 1 == utf8_position_to_utf16_offset(s, 1) + assert 2 == utf8_position_to_utf16_offset(s, 2) + assert 2 == utf8_position_to_utf16_offset(s, 3) + assert 2 == utf8_position_to_utf16_offset(s, 4) + end + + test "caps offsets at the end of the string and beyond" do + line = "🎸" + assert 2 == utf8_position_to_utf16_offset(line, 1) + assert 2 == utf8_position_to_utf16_offset(line, 2) + assert 2 == utf8_position_to_utf16_offset(line, 3) + assert 2 == utf8_position_to_utf16_offset(line, 4) + end + + test "handles multi-byte characters properly" do + # guitar is 2 code units in utf16 but 4 in utf8 + line = "b🎸abc" + assert 0 == utf8_position_to_utf16_offset(line, 0) + assert 1 == utf8_position_to_utf16_offset(line, 1) + assert 3 == utf8_position_to_utf16_offset(line, 2) + assert 4 == utf8_position_to_utf16_offset(line, 3) + assert 5 == utf8_position_to_utf16_offset(line, 4) + assert 6 == utf8_position_to_utf16_offset(line, 5) + assert 6 == utf8_position_to_utf16_offset(line, 6) + end + end + + describe "utf16_offset_to_utf8_offset" do + test "with a multi-byte character" do + line = "🏳️‍🌈" + + code_unit_count = count_utf8_code_units(line) + + assert utf16_offset_to_utf8_offset(line, 0) == {:ok, 1} + assert utf16_offset_to_utf8_offset(line, 1) == {:error, :misaligned} + assert utf16_offset_to_utf8_offset(line, 2) == {:ok, 5} + assert utf16_offset_to_utf8_offset(line, 3) == {:ok, 8} + assert utf16_offset_to_utf8_offset(line, 4) == {:ok, 11} + assert utf16_offset_to_utf8_offset(line, 5) == {:error, :misaligned} + assert utf16_offset_to_utf8_offset(line, 6) == {:ok, code_unit_count + 1} + end + + test "after a unicode character" do + line = " {\"🎸\", \"ok\"}" + + assert utf16_offset_to_utf8_offset(line, 0) == {:ok, 1} + assert utf16_offset_to_utf8_offset(line, 1) == {:ok, 2} + assert utf16_offset_to_utf8_offset(line, 4) == {:ok, 5} + assert utf16_offset_to_utf8_offset(line, 5) == {:ok, 6} + assert utf16_offset_to_utf8_offset(line, 6) == {:ok, 7} + assert utf16_offset_to_utf8_offset(line, 7) == {:error, :misaligned} + # after the guitar character + assert utf16_offset_to_utf8_offset(line, 8) == {:ok, 11} + assert utf16_offset_to_utf8_offset(line, 9) == {:ok, 12} + assert utf16_offset_to_utf8_offset(line, 10) == {:ok, 13} + assert utf16_offset_to_utf8_offset(line, 11) == {:ok, 14} + assert utf16_offset_to_utf8_offset(line, 12) == {:ok, 15} + assert utf16_offset_to_utf8_offset(line, 13) == {:ok, 16} + assert utf16_offset_to_utf8_offset(line, 17) == {:ok, 20} + end + end + + defp count_utf8_code_units(utf8_string) do + byte_size(utf8_string) + end +end diff --git a/forge/test/lexical/math_test.exs b/forge/test/lexical/math_test.exs new file mode 100644 index 00000000..1eb61a27 --- /dev/null +++ b/forge/test/lexical/math_test.exs @@ -0,0 +1,40 @@ +defmodule Forge.MathTest do + alias Forge.Math + + use ExUnit.Case, async: true + use ExUnitProperties + + describe "clamp/3" do + test "returns low when value is less than low" do + assert Math.clamp(-5, 0, 5) == 0 + end + + test "returns value when value is between low and high" do + assert Math.clamp(3, 0, 5) == 3 + end + + test "returns high when value is greater than high" do + assert Math.clamp(6, 0, 5) == 5 + end + end + + def low_mid_high(unique_list) do + [low | rest] = Enum.sort(unique_list) + + mid_index = trunc(length(rest) / 2) + mid = Enum.at(rest, mid_index) + high = List.last(rest) + [low, mid, high] + end + + property "clamp works with all integers" do + check all( + ints <- uniq_list_of(integer(-100_000..100_000), min_length: 5, max_length: 20), + [low, mid, high] = low_mid_high(ints) + ) do + assert Math.clamp(mid, low, high) == mid + assert Math.clamp(low, mid, high) == mid + assert Math.clamp(high, low, mid) == mid + end + end +end diff --git a/forge/test/lexical/vm/versions_test.exs b/forge/test/lexical/vm/versions_test.exs new file mode 100644 index 00000000..a06d2da8 --- /dev/null +++ b/forge/test/lexical/vm/versions_test.exs @@ -0,0 +1,115 @@ +defmodule Forge.VM.VersionTest do + alias Forge.VM.Versions + use ExUnit.Case + use Patch + import Versions + + test "it gets the current version" do + assert current().elixir == System.version() + end + + test "it gets the current erlang version" do + patch(Versions, :erlang_version, fn -> "25.3.2.1" end) + assert current().erlang == "25.3.2.1" + end + + test "it reads the versions in a directory" do + patch(Versions, :read_file, fn "/foo/bar/baz/" <> file -> + if String.ends_with?(file, ".erlang") do + {:ok, "25.3.2.2"} + else + {:ok, "14.5.2"} + end + end) + + assert {:ok, tags} = read("/foo/bar/baz") + + assert tags.elixir == "14.5.2" + assert tags.erlang == "25.3.2.2" + end + + test "it writes the versions" do + patch(Versions, :erlang_version, "25.3.2.1") + patch(Versions, :write_file!, :ok) + + elixir_version = System.version() + + assert write("/foo/bar/baz") + assert_called(Versions.write_file!("/foo/bar/baz/.erlang", "25.3.2.1")) + assert_called(Versions.write_file!("/foo/bar/baz/.elixir", ^elixir_version)) + end + + def patch_system_versions(elixir, erlang) do + patch(Versions, :elixir_version, elixir) + patch(Versions, :erlang_version, erlang) + end + + def patch_tagged_versions(elixir, erlang) do + patch(Versions, :read_file, fn file -> + if String.ends_with?(file, ".elixir") do + {:ok, elixir} + else + {:ok, erlang} + end + end) + end + + def with_exposed_normalize(_) do + expose(Versions, normalize: 1) + :ok + end + + describe "normalize/1" do + setup [:with_exposed_normalize] + + test "fixes a two-element version" do + assert "25.0.0" == private(Versions.normalize("25.0")) + end + + test "keeps three-element versions the same" do + assert "25.3.2" == private(Versions.normalize("25.3.2")) + end + + test "truncates versions with more than three elements" do + assert "25.3.2" == private(Versions.normalize("25.3.2.2")) + + # I can't imagine they'd do this, but, you know, belt and suspenders + assert "25.3.2" == private(Versions.normalize("25.3.2.1.2")) + assert "25.3.2" == private(Versions.normalize("25.3.2.4.2.3")) + end + end + + test "an untagged directory is not compatible" do + refute compatible?(System.tmp_dir!()) + end + + describe "compatible?/1" do + test "lower major versions of erlang are compatible with later major versions" do + patch_system_versions("1.14.5", "26.0") + patch_tagged_versions("1.14.5", "25.0") + + assert compatible?("/foo/bar/baz") + end + + test "higher major versions are not compatible with lower major versions" do + patch_system_versions("1.14.5", "25.0") + patch_tagged_versions("1.14.5", "26.0") + + refute compatible?("/foo/bar/baz") + end + + test "the same versions are compatible with each other" do + patch_system_versions("1.14.5", "25.3.3") + patch_tagged_versions("1.14.5", "25.0") + + assert compatible?("/foo/bar/baz") + end + + test "higher minor versions are compatible" do + patch_system_versions("1.14.5", "25.3.0") + patch_tagged_versions("1.14.5", "25.0") + + assert compatible?("/foo/bar/baz") + end + end +end diff --git a/forge/test/support/lexical/test/detection_case.ex b/forge/test/support/lexical/test/detection_case.ex new file mode 100644 index 00000000..e8551a7c --- /dev/null +++ b/forge/test/support/lexical/test/detection_case.ex @@ -0,0 +1,337 @@ +defmodule Forge.Test.DetectionCase do + alias Forge.Ast + alias Forge.Ast.Analysis + alias Forge.Ast.Tokens + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range + alias Forge.Test.DetectionCase.Suite + alias Forge.Test.Variations + + import Forge.Test.RangeSupport + import ExUnit.Assertions + use ExUnit.CaseTemplate + + using(args) do + context = Keyword.fetch!(args, :for) + assertion_query = Keyword.fetch!(args, :assertions) + variations = Keyword.get(args, :variations, []) ++ [:nothing] + # sometimes one type of thing can be found in another (for example, a struct reference is + # found in a struct field case), so we don't want to build a refutation + # for that thing. `skip` allows us to remove certain cases from refutes. + skip = Keyword.get(args, :skip, []) + + {assertions, refutes} = Enum.split_with(Suite.get(), &matches?(&1, assertion_query)) + + if Enum.empty?(assertions) do + query = + assertion_query + |> Macro.expand(__CALLER__) + |> Macro.to_string() + + flunk("No assertions matched the query #{query}") + end + + refutes = Enum.reject(refutes, &matches?(&1, skip)) + assertions = build_assertion_cases(context, assertions, variations) + refutations = build_refutation_cases(context, refutes, variations) + + quote location: :keep do + @context unquote(context) + alias Forge.Test.DetectionCase + + import Forge.Test.CodeSigil + + import unquote(__MODULE__), + only: [ + assert_detected: 2, + refute_detected: 2 + ] + + unquote_splicing(assertions) + unquote_splicing(refutations) + + def assert_detected(code) do + assert_detected @context, code + end + + def refute_detected(code) do + refute_detected @context, code + end + end + end + + def refute_detected(context, code) do + document = Document.new("file:///file.ex", code, 1) + analysis = Ast.analyze(document) + + for position <- position_stream(document) do + try do + refute context.detected?(analysis, position) + rescue + e in ExUnit.AssertionError -> + flunk(error_for(document, position, context, e)) + end + end + end + + def assert_detected(context, code) do + {ranges, code} = pop_all_ranges(code) + + document = Document.new("file:///file.ex", code, 1) + analysis = Ast.analyze(document) + assert_contexts_in_range(analysis, context, ranges) + end + + defp includes?(%Range{} = range, %Position{} = position) do + cond do + range.start.line == position.line and range.end.line == position.line -> + position.character >= range.start.character and + position.character <= range.end.character + + range.start.line == position.line -> + position.character >= range.start.character + + range.end.line == position.line -> + position.character <= range.end.character + + true -> + position.line > range.start.line and position.line < range.end.line + end + end + + defp matches?({type, _}, assertions) do + Enum.any?(assertions, &wildcard_matches?(&1, type)) + end + + defp wildcard_matches?(wildcard, type) do + wildcard + |> Enum.zip(type) + |> Enum.reduce_while(true, fn + {same, same}, _ -> + {:cont, true} + + {:*, _}, _ -> + {:halt, true} + + {_, _}, _ -> + {:halt, false} + end) + end + + defp build_assertion_cases(context, assertions, variations) do + for {type, test} <- assertions, + variation <- variations do + build_assertion_variation(context, type, variation, test) + end + end + + defp build_assertion_variation(context, type, variation, test) do + assertion_text = Variations.wrap_with(variation, test) + test_name = type_to_name(type, variation) + + quote generated: true do + test unquote(test_name) do + assert_detected unquote(context), unquote(assertion_text) + end + end + end + + defp assert_contexts_in_range(%Analysis{} = analysis, context, ranges) do + positions_by_range = + analysis.document + |> position_stream() + |> Enum.group_by(fn position -> Enum.find(ranges, &includes?(&1, position)) end) + + for {range, positions} <- positions_by_range, + position <- positions do + try do + if range do + assert context.detected?(analysis, position) + else + refute context.detected?(analysis, position) + end + rescue + e in ExUnit.AssertionError -> + analysis.document + |> error_for(position, context, e) + |> ExUnit.Assertions.flunk() + end + end + end + + defp build_refutation_cases(context, assertions, variations) do + for {type, test} <- assertions, + variation <- variations do + build_refutation_variation(context, type, variation, test) + end + end + + defp build_refutation_variation(context, type, variation, test) do + {_range, refutation_text} = + variation + |> Variations.wrap_with(test) + |> pop_range() + + test_name = type_to_name(type, variation) + + quote generated: true do + test unquote(test_name) do + refute_detected unquote(context), unquote(refutation_text) + end + end + end + + defp error_for(%Document{} = doc, %Position{} = pos, context, assertion_error) do + message = message_for_assertion_type(assertion_error, context, pos) + + test_text = + doc + |> insert_cursor(pos) + |> Document.to_string() + + [ + IO.ANSI.red(), + message, + IO.ANSI.reset(), + "\n", + "document:", + "\n\n", + test_text, + "\n\n" + ] + |> IO.ANSI.format() + |> IO.iodata_to_binary() + end + + defp message_for_assertion_type(%ExUnit.AssertionError{} = error, context, position) do + context = context |> Module.split() |> List.last() + + case assertion_type(error.expr) do + :assert -> + "The cursor at {#{position.line}, #{position.character}} should have been detected as a #{context}, but it wasn't." + + :refute -> + "The cursor at {#{position.line}, #{position.character}} was detected as #{context}, but it shouldn't have been" + end + end + + defp assertion_type({type, _, _}) do + case Atom.to_string(type) do + "assert" <> _ -> :assert + _ -> :refute + end + end + + defp insert_cursor(%Document{} = document, %Position{} = position) do + cursor = + [ + IO.ANSI.bright(), + IO.ANSI.light_red(), + "|", + IO.ANSI.reset() + ] + |> IO.ANSI.format() + |> IO.iodata_to_binary() + + range = Range.new(position, position) + edit = Document.Edit.new(cursor, range) + {:ok, document} = Document.apply_content_changes(document, document.version + 1, [edit]) + + document + end + + defp type_to_name(type, variation) do + words = fn atom -> + atom + |> Atom.to_string() + |> String.split("_") + |> Enum.join(" ") + end + + base_name = Enum.map_join(type, ", ", words) + + variation = + if variation == :nothing do + "" + else + "(inside #{words.(variation)})" + end + + "#{base_name} #{variation}" + end + + def position_stream(%Document{} = document) do + line_count = Document.size(document) + + init_fn = fn -> + 1 + end + + next_fn = fn + line_number when line_number <= line_count -> + case Document.fetch_text_at(document, line_number) do + {:ok, line_text} -> + token_positions = + document + |> Tokens.prefix_stream( + Position.new(document, line_number, String.length(line_text) + 1) + ) + |> Stream.filter(fn + {_token, _, {^line_number, _character}} -> + true + + _ -> + false + end) + |> Enum.reduce( + [], + fn + {:string, contents, position}, acc -> + string_literal_positions(document, contents, position) ++ acc + + {:interpolated_string, interpolations, _}, acc -> + interpolation_positions(document, interpolations) ++ acc + + {_token_type, _token, {_line, character}}, acc -> + pos = Position.new(document, line_number, character) + [pos | acc] + end + ) + + {token_positions, line_number + 1} + end + + _ -> + {:halt, :ok} + end + + finalize = fn _ -> :ok end + + Stream.resource(init_fn, next_fn, finalize) + end + + defp string_literal_positions(%Document{} = document, string_contents, {line, column}) do + # add two for the quotes + string_length = String.length(string_contents) + 2 + before_pos = Position.new(document, line, column + 1) + after_pos = Position.new(document, line, column + string_length) + + [after_pos, before_pos] + end + + defp interpolation_positions(%Document{} = document, interpolations) do + interpolations + |> Enum.flat_map(fn {_, _, {{start_line, start_col}, {_end_line, end_col}}} -> + in_between_positions = + Enum.map(start_col..end_col, fn column -> + Position.new(document, start_line, column) + end) + + start_pos = Position.new(document, start_line, start_col) + + [start_pos | in_between_positions] + end) + |> Enum.uniq() + end +end diff --git a/forge/test/support/lexical/test/detection_case/suite.ex b/forge/test/support/lexical/test/detection_case/suite.ex new file mode 100644 index 00000000..7e531999 --- /dev/null +++ b/forge/test/support/lexical/test/detection_case/suite.ex @@ -0,0 +1,309 @@ +defmodule Forge.Test.DetectionCase.Suite do + @moduledoc """ + Defines a test suite for the detection case tests. + """ + import Forge.Test.CodeSigil + + @doc """ + Returns a list of tuples where: + + The first element is the path of the suite. Test cases can select and + skip parts of the suite based on the path + + The second element is the code, defined via the code sigil. The code can contain + multiple ranges, defined with the `«` and `»` characters. Ranges define the areas + of the code that contain the part of the code that is expected to be detected by + the recognizer with the same name as the first element of the list. + """ + + def suite do + [ + alias: [ + single: ~q(alias F«oo»), + multiple: ~q( + alias M«yModule.{ + First, + Second, + Third» + } + ), + as: ~q[alias M«yModule.Submodule, as: Alias»], + # Note: we need the token after the alias for the test, since + # we can't place a range on an empty space + multiple_on_one_line: ~q[alias F«oo.{Bar, Baz, Quux»};3 ] + ], + bitstring: [ + one_line: ~q[<<«foo::integer, bar::binary»>>], + multi_line: ~q[ + <<«foo::integer, + bar::binary-size(6) + »>> + ] + ], + callbacks: [ + callback: [ + zero_arg: "@«callback my_cb() :: boolean()»", + one_arg: "@«callback my_cb(foo :: integer) :: String.t()»", + multiple_args: "@«callback my_cb(foo :: integer, bar:: String.t()) :: [pos_integer()]»", + multiple_line: """ + @«callback my_cb( + foo :: String.t(), + bar :: pos_integer()) :: pos_integer()» + """ + ], + macrocallback: [ + zero_arg: "@«macrocallback my_cb() :: boolean()»", + one_arg: "@«macrocallback my_cb(foo :: integer) :: String.t()»", + multiple_args: + "@«macrocallback my_cb(foo :: integer, bar:: String.t()) :: [pos_integer()]»", + multiple_line: """ + @«macrocallback my_cb( + foo :: String.t(), + bar :: pos_integer()) :: pos_integer()» + """ + ] + ], + comment: [ + start_of_line: "«# IO.puts»", + end_of_line: "IO.puts(thing) «# IO.puts»" + ], + doc: [ + empty: ~S[@«doc ""»], + false: "@«doc false»", + single_line: ~S[@«doc "this is my doc»"], + multi_line: ~S[@«doc """ + This is the doc + """» + ] + ], + function_capture: [ + local_arity: ~q[&«my_fun/1»], + local_argument: ~q[&«my_fun(arg, &1)»], + remote_arity: ~q[&«Remote.my_fun/1»], + remote_argument: ~q[&«Remote.my_fun(arg, &1)»] + ], + import: [ + single: ~q(import« MyModule»), + chain: ~q(import« MyModule.SubModule»), + only: [ + single_line: ~q(import« OtherModule, only: [something: 3, other_thing: 2]»), + multi_line: ~q(import« OtherModule, only: »[ + something: 3, + other_thing: 2 + ]) + ], + except: [ + single_line: ~q(import« OtherModule, except: [something: 3, other_thing: 2]»), + multi_line: ~q(import« OtherModule, except: »[ + something: 3, + other_thing: 2 + ]) + ] + ], + keyword: [ + single_line: + ~q(«string: "value", atom: :value2, int: 6, float: 2.0, list: [1, 2], tuple: {3, 4}»), + multi_line: ~q( + [« + string: "value", + atom: :value2, + int: 6, + float: 2.0, + list: [1, 2], + tuple: {3, 4} + »]) + ], + map: [ + single_line: + ~q(%{«string: "value", atom: :value2, int: 6 float: 2.0, list: [1, 2], tuple: {3, 4}}») + ], + module_doc: [ + empty: ~S[@«moduledoc ""»], + false: "@«moduledoc false»", + single_line: ~S[@«moduledoc "this is my moduledoc»"], + multi_line: ~S[@«moduledoc """ + This is the moduledoc + """» + ] + ], + module_attribute: [ + single_line: "@«attr 45»", + multi_line_pipe: """ + @«attr other_thing» + |> «Enum.shuffle()» + |> «Enum.max()» + """, + multi_line_list: """ + @«attrs [» + «:foo», + «:bar», + «:baz» + ] + """ + ], + pipe: [ + one_line: ~q[foo |> «bar»() |> «RemoteCall.fun»() |> «:remote_erlang.call»()], + multi_line: ~q[ + document + |> «local_call»() + |> «RemoteModule.call»() + |> «:remote_erlang.call»() + ] + ], + require: [ + single: ~q(require« MyModule»), + chain: ~q(require« MyModule.Submodule») + ], + spec: [ + simple_function: ~q{@spec« function_name(String.t) :: any()»}, + multi_line: ~q{ + @spec «on_multiple_lines :: integer()» + | «String.t()» + | «something()» + }, + or_type: ~q{@spec« my_func() :: :yours | :mine | :the_truth»} + ], + struct_field_key: [ + simple: ~q[%User{«foo:» 3,« bar:» 8}] + ], + struct_field_value: [ + single_line: ~q[%User{field_name:« 3», next_name:« :atom»}] + ], + struct_fields: [ + one_line: [ + empty: ~q[%User{«»}], + simple: ~q[%User{«field_name: 3, other_name: 9»}] + ], + multi_line: [ + simple: ~q[ + %Struct{« + amount: 1, + kind: :tomatoes» + } + ] + ] + ], + strings: [ + literal: ~q["«this is a string»"], + interpolation: [ + variable: ~S["«before »#{interp}« after»"], + math: ~S["«before »#{3 + 1}« after»"], + function_call: ~S["«before »#{my_fun(arg)}« after»"], + multiple: ~S["«before »#{first}« middle »#{second}« after»"] + ], + heredocs: [ + simple: ~S[ + """ + «This is in the heredoc + It's multiple lines» + """ + ], + interpolation: ~S[ + """ + «This is the heredoc + #{something} is interpolated» + """ + ] + ], + sigils: [ + s: [ + single_line: ~S[ + ~s/«this is a string»/ + ], + multi_line: ~S[ + ~s/« + this is a string + that spans + many lines + »/ + ] + ], + S: [ + single_line: ~S[ + ~S/«this is a string»/ + ], + multi_line: ~S[ + ~S/« + this is a string + that spans + many lines + »/ + ] + ] + ] + ], + struct_reference: [ + single_line: ~q(%U«ser»{#{keys_and_values()}}), + nested: ~q[%U«ser»{account: %A«ccount»{#{keys_and_values()}}}] + ], + type: [ + private: ~q[@typep« my_type :: integer()»], + opaque: ~q[@opaque« opaque :: integer()»], + single_line: [ + simple: ~q[@type« my_type :: integer()»], + composite: ~q[@type« my_type :: :foo | :bar | :baz»] + ], + multi_line: [ + composite: ~q[ + @type« multi_line ::» + «integer()» + |« String.t()» + |« Something.t()» + ] + ] + ], + use: [ + simple: ~q(use« SomeModule»), + params: [ + single_line: ~q(use« SomeModule, param: 3, other_param: :doggy»), + multi_line: ~q( + use «SomeModule, »[ + with: :features, + that_are: :great + ] + ) + ] + ] + ] + end + + def get do + flatten(suite()) + end + + defp flatten(keyword) do + keyword + |> do_flatten([], []) + |> Enum.map(fn {path, value} -> {Enum.reverse(path), value} end) + end + + defp do_flatten(keyword, prefix, acc) do + Enum.reduce(keyword, acc, fn + {k, v}, acc when is_list(v) -> + do_flatten(v, [k | prefix], acc) + + {k, v}, acc -> + [{[k | prefix], v} | acc] + end) + end + + defp list_literal do + ~q([:atom, 1, 2.0, "string", %{a: 1, b: 2}, [1, 2, 3], {1, 2}]) + end + + defp map_literal do + ~q(%{foo: 3, bar: 6}) + end + + defp keyword_literal do + ~q([key_1: 3, key_2: #{list_literal()}]) + end + + defp tuple_litral do + ~q({:atom, 1, 2.0, "string", %{a: 1, b: 2}, [1, 2, 3], {1, 2}}) + end + + defp keys_and_values do + ~q(string: "value", atom: :value2, int: 6 float: 2.0, keyword: #{keyword_literal()} map: #{map_literal()}, list: #{list_literal()}, tuple: #{tuple_litral()}) + end +end diff --git a/forge/test/support/lexical/test/variations.ex b/forge/test/support/lexical/test/variations.ex new file mode 100644 index 00000000..febe54d3 --- /dev/null +++ b/forge/test/support/lexical/test/variations.ex @@ -0,0 +1,50 @@ +defmodule Forge.Test.Variations do + def wrap_with(:nothing, text) do + text + end + + def wrap_with(:match, text) do + """ + x = #{text} + """ + end + + def wrap_with(:module, text) do + """ + defmodule MyModule do + #{text} + end + """ + end + + def wrap_with(:function_body, text) do + body = """ + def func do + #{text} + end + """ + + wrap_with(:module, body) + end + + def wrap_with(:function_arguments, text) do + args = """ + def func(#{text}) do + end + """ + + wrap_with(:module, args) + end + + def wrap_with(:comprehension_generator, text) do + """ + for x <- #{text} do + x + end + """ + end + + def wrap_with(:function_call, text) do + "Enum.map(things, #{text})" + end +end diff --git a/forge/test/test_helper.exs b/forge/test/test_helper.exs new file mode 100644 index 00000000..db057cfd --- /dev/null +++ b/forge/test/test_helper.exs @@ -0,0 +1,2 @@ +Application.ensure_all_started(:snowflake) +ExUnit.start() From d3a33d7fa57a9c67b838048e5bbfc09306d56841 Mon Sep 17 00:00:00 2001 From: Mitchell Hanberg Date: Sun, 5 Jan 2025 14:47:28 -0500 Subject: [PATCH 07/12] wip: move more things into forge --- engine/lib/{engine => }/engine.ex | 0 engine/lib/engine/analyzer/imports.ex | 2 +- engine/lib/engine/build.ex | 2 +- engine/lib/engine/build/document/compiler.ex | 2 +- .../engine/build/document/compilers/config.ex | 2 +- engine/lib/engine/build/state.ex | 2 +- engine/lib/engine/code_mod/diff.ex | 2 +- engine/lib/engine/commands/reindex.ex | 2 +- engine/lib/engine/search/indexer.ex | 4 ++-- engine/lib/engine/search/indexer/entry.ex | 2 +- .../search/indexer/extractors/module.ex | 2 +- engine/lib/engine/search/indexer/quoted.ex | 2 +- .../lib/engine/search/indexer/source/block.ex | 2 +- .../engine/search/store/backends/ets/wal.ex | 4 ++-- engine/mix.exs | 2 ++ engine/mix.lock | 4 ++++ .../engine => forge/lib/forge}/convertible.ex | 22 +++++++++---------- .../lib/engine => forge/lib/forge}/math.ex | 2 +- .../lib/forge}/process_cache.ex | 2 +- forge/lib/forge/project.ex | 4 ++-- forge/mix.exs | 4 +++- forge/mix.lock | 4 ++++ 22 files changed, 43 insertions(+), 31 deletions(-) rename engine/lib/{engine => }/engine.ex (100%) rename {engine/lib/engine => forge/lib/forge}/convertible.ex (93%) rename {engine/lib/engine => forge/lib/forge}/math.ex (95%) rename {engine/lib/engine => forge/lib/forge}/process_cache.ex (98%) create mode 100644 forge/mix.lock diff --git a/engine/lib/engine/engine.ex b/engine/lib/engine.ex similarity index 100% rename from engine/lib/engine/engine.ex rename to engine/lib/engine.ex diff --git a/engine/lib/engine/analyzer/imports.ex b/engine/lib/engine/analyzer/imports.ex index a6bdd339..f3389951 100644 --- a/engine/lib/engine/analyzer/imports.ex +++ b/engine/lib/engine/analyzer/imports.ex @@ -4,7 +4,7 @@ defmodule Engine.Analyzer.Imports do alias Forge.Ast.Analysis.Scope alias Forge.Document.Position alias Forge.Document.Range - alias Engine.ProcessCache + alias Forge.ProcessCache alias Engine.Analyzer.Aliases alias Engine.Module.Loader diff --git a/engine/lib/engine/build.ex b/engine/lib/engine/build.ex index d4d36b92..32ab3e70 100644 --- a/engine/lib/engine/build.ex +++ b/engine/lib/engine/build.ex @@ -4,7 +4,7 @@ defmodule Engine.Build do alias Engine.Build.Document.Compilers.HEEx alias Engine.Build.State - alias Engine.VM.Versions + alias Forge.VM.Versions require Logger use GenServer diff --git a/engine/lib/engine/build/document/compiler.ex b/engine/lib/engine/build/document/compiler.ex index 71e7e52d..4dd0d46e 100644 --- a/engine/lib/engine/build/document/compiler.ex +++ b/engine/lib/engine/build/document/compiler.ex @@ -3,7 +3,7 @@ defmodule Engine.Build.Document.Compiler do A behaviour for document-level compilers """ alias Forge.Document - alias Engine.Plugin.V1.Diagnostic + alias Forge.Plugin.V1.Diagnostic @type compile_response :: {:ok, [Diagnostic.Result.t()]} | {:error, [Diagnostic.Result.t()]} diff --git a/engine/lib/engine/build/document/compilers/config.ex b/engine/lib/engine/build/document/compilers/config.ex index ec8df84b..bdfb7bfd 100644 --- a/engine/lib/engine/build/document/compilers/config.ex +++ b/engine/lib/engine/build/document/compilers/config.ex @@ -4,7 +4,7 @@ defmodule Engine.Build.Document.Compilers.Config do """ alias Elixir.Features alias Forge.Document - alias Engine.Plugin.V1.Diagnostic + alias Forge.Plugin.V1.Diagnostic alias Engine.Build alias Engine.Build.Error.Location diff --git a/engine/lib/engine/build/state.ex b/engine/lib/engine/build/state.ex index ebc31397..eeac1840 100644 --- a/engine/lib/engine/build/state.ex +++ b/engine/lib/engine/build/state.ex @@ -5,7 +5,7 @@ defmodule Engine.Build.State do alias Engine.Api.Messages alias Engine.Build - alias Engine.VM.Versions + alias Forge.VM.Versions require Logger diff --git a/engine/lib/engine/code_mod/diff.ex b/engine/lib/engine/code_mod/diff.ex index b175af56..3524fa4f 100644 --- a/engine/lib/engine/code_mod/diff.ex +++ b/engine/lib/engine/code_mod/diff.ex @@ -1,5 +1,5 @@ defmodule Engine.CodeMod.Diff do - alias Engine.CodeUnit + alias Forge.CodeUnit alias Forge.Document alias Forge.Document.Edit alias Forge.Document.Position diff --git a/engine/lib/engine/commands/reindex.ex b/engine/lib/engine/commands/reindex.ex index 3c8e0c7d..bd5e06f9 100644 --- a/engine/lib/engine/commands/reindex.ex +++ b/engine/lib/engine/commands/reindex.ex @@ -2,7 +2,7 @@ defmodule Engine.Commands.Reindex do defmodule State do alias Forge.Ast.Analysis alias Forge.Document - alias Engine.ProcessCache + alias Forge.ProcessCache alias Engine.Search alias Engine.Search.Indexer diff --git a/engine/lib/engine/search/indexer.ex b/engine/lib/engine/search/indexer.ex index d6bb9717..41dd4db0 100644 --- a/engine/lib/engine/search/indexer.ex +++ b/engine/lib/engine/search/indexer.ex @@ -1,6 +1,6 @@ defmodule Engine.Search.Indexer do - alias Engine.Identifier - alias Engine.ProcessCache + alias Forge.Identifier + alias Forge.ProcessCache alias Forge.Project alias Engine.Progress diff --git a/engine/lib/engine/search/indexer/entry.ex b/engine/lib/engine/search/indexer/entry.ex index 11933a15..cc87ec88 100644 --- a/engine/lib/engine/search/indexer/entry.ex +++ b/engine/lib/engine/search/indexer/entry.ex @@ -50,7 +50,7 @@ defmodule Engine.Search.Indexer.Entry do @type datetime_format :: :erl | :unix | :datetime @type date_type :: :calendar.datetime() | integer() | DateTime.t() - alias Engine.Identifier + alias Forge.Identifier alias Engine.Search.Indexer.Source.Block alias Forge.StructAccess diff --git a/engine/lib/engine/search/indexer/extractors/module.ex b/engine/lib/engine/search/indexer/extractors/module.ex index 9bf3dfd1..c0145e2a 100644 --- a/engine/lib/engine/search/indexer/extractors/module.ex +++ b/engine/lib/engine/search/indexer/extractors/module.ex @@ -6,7 +6,7 @@ defmodule Engine.Search.Indexer.Extractors.Module do alias Forge.Ast alias Forge.Document.Position alias Forge.Document.Range - alias Engine.ProcessCache + alias Forge.ProcessCache alias Engine.Search.Indexer.Entry alias Engine.Search.Indexer.Metadata diff --git a/engine/lib/engine/search/indexer/quoted.ex b/engine/lib/engine/search/indexer/quoted.ex index b01b8d3b..e3752061 100644 --- a/engine/lib/engine/search/indexer/quoted.ex +++ b/engine/lib/engine/search/indexer/quoted.ex @@ -1,6 +1,6 @@ defmodule Engine.Search.Indexer.Quoted do alias Forge.Ast.Analysis - alias Engine.ProcessCache + alias Forge.ProcessCache alias Engine.Search.Indexer.Source.Reducer require ProcessCache diff --git a/engine/lib/engine/search/indexer/source/block.ex b/engine/lib/engine/search/indexer/source/block.ex index 766869fa..b91f4a2d 100644 --- a/engine/lib/engine/search/indexer/source/block.ex +++ b/engine/lib/engine/search/indexer/source/block.ex @@ -4,7 +4,7 @@ defmodule Engine.Search.Indexer.Source.Block do """ defstruct [:starts_at, :ends_at, :id, :parent_id] - alias Engine.Identifier + alias Forge.Identifier def root do %__MODULE__{id: :root} diff --git a/engine/lib/engine/search/store/backends/ets/wal.ex b/engine/lib/engine/search/store/backends/ets/wal.ex index c7a70daf..401e6f5a 100644 --- a/engine/lib/engine/search/store/backends/ets/wal.ex +++ b/engine/lib/engine/search/store/backends/ets/wal.ex @@ -2,9 +2,9 @@ defmodule Engine.Search.Store.Backends.Ets.Wal do @moduledoc """ A (hopefully) simple write-ahead log """ - alias Engine.Identifier + alias Forge.Identifier alias Forge.Project - alias Engine.VM.Versions + alias Forge.VM.Versions import Record diff --git a/engine/mix.exs b/engine/mix.exs index 4f1f5cda..7268b5aa 100644 --- a/engine/mix.exs +++ b/engine/mix.exs @@ -24,6 +24,8 @@ defmodule Engine.MixProject do [ {:forge, path: "../forge"}, {:spitfire, "~> 0.1"}, + {:elixir_sense, github: "elixir-lsp/elixir_sense"}, + {:path_glob, "~> 0.2.0"}, {:sourceror, "~> 1.0"}, # {:gen_lsp, "~> 0.10"}, {:gen_lsp, diff --git a/engine/mix.lock b/engine/mix.lock index 08c4163e..9130538a 100644 --- a/engine/mix.lock +++ b/engine/mix.lock @@ -1,9 +1,13 @@ %{ "beam_file": {:hex, :beam_file, "0.6.2", "efd54ec60be6a03f0a8f96f72b0353427196613289c46032d3500f0ab6c34d32", [:mix], [], "hexpm", "09a99e8e5aad674edcad7213b0d7602375dfd3c7d02f8e3136e3efae0bcc9c56"}, + "elixir_sense": {:git, "https://github.com/elixir-lsp/elixir_sense.git", "809a0924b40562d3c779e481a3c8970a52640c21", []}, "gen_lsp": {:git, "https://github.com/elixir-tools/gen_lsp.git", "f63f284289ef61b678ab6bd2cbcf3a6ba3d9fcdd", [branch: "change-schematic-function"]}, "jason": {:hex, :jason, "1.4.4", "b9226785a9aa77b6857ca22832cffa5d5011a667207eb2a0ad56adb5db443b8a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "c5eb0cab91f094599f94d55bc63409236a8ec69a21a67814529e8d5f6cc90b3b"}, "nimble_options": {:hex, :nimble_options, "1.1.1", "e3a492d54d85fc3fd7c5baf411d9d2852922f66e69476317787a7b2bb000a61b", [:mix], [], "hexpm", "821b2470ca9442c4b6984882fe9bb0389371b8ddec4d45a9504f00a66f650b44"}, + "nimble_parsec": {:hex, :nimble_parsec, "1.2.3", "244836e6e3f1200c7f30cb56733fd808744eca61fd182f731eac4af635cc6d0b", [:mix], [], "hexpm", "c8d789e39b9131acf7b99291e93dae60ab48ef14a7ee9d58c6964f59efb570b0"}, + "path_glob": {:hex, :path_glob, "0.2.0", "b9e34b5045cac5ecb76ef1aa55281a52bf603bf7009002085de40958064ca312", [:mix], [{:nimble_parsec, "~> 1.2.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "be2594cb4553169a1a189f95193d910115f64f15f0d689454bb4e8cfae2e7ebc"}, "schematic": {:hex, :schematic, "0.2.1", "0b091df94146fd15a0a343d1bd179a6c5a58562527746dadd09477311698dbb1", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "0b255d65921e38006138201cd4263fd8bb807d9dfc511074615cd264a571b3b1"}, + "snowflake": {:hex, :snowflake, "1.0.4", "8433b4e04fbed19272c55e1b7de0f7a1ee1230b3ae31a813b616fd6ef279e87a", [:mix], [], "hexpm", "badb07ebb089a5cff737738297513db3962760b10fe2b158ae3bebf0b4d5be13"}, "sourceror": {:hex, :sourceror, "1.7.1", "599d78f4cc2be7d55c9c4fd0a8d772fd0478e3a50e726697c20d13d02aa056d4", [:mix], [], "hexpm", "cd6f268fe29fa00afbc535e215158680a0662b357dc784646d7dff28ac65a0fc"}, "spitfire": {:hex, :spitfire, "0.1.3", "7ea0f544005dfbe48e615ed90250c9a271bfe126914012023fd5e4b6b82b7ec7", [:mix], [], "hexpm", "d53b5107bcff526a05c5bb54c95e77b36834550affd5830c9f58760e8c543657"}, "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"}, diff --git a/engine/lib/engine/convertible.ex b/forge/lib/forge/convertible.ex similarity index 93% rename from engine/lib/engine/convertible.ex rename to forge/lib/forge/convertible.ex index 85b40f06..c49ee8d9 100644 --- a/engine/lib/engine/convertible.ex +++ b/forge/lib/forge/convertible.ex @@ -1,4 +1,4 @@ -defmodule Engine.Convertible.Helpers do +defmodule Forge.Convertible.Helpers do @moduledoc false alias Forge.Document @@ -83,7 +83,7 @@ defmodule Engine.Convertible.Helpers do end end -defprotocol Engine.Convertible do +defprotocol Forge.Convertible do @moduledoc """ A protocol that details conversions to and from Language Server idioms @@ -133,9 +133,9 @@ defprotocol Engine.Convertible do def to_lsp(t) end -defimpl Engine.Convertible, for: List do - alias Engine.Convertible - alias Engine.Convertible.Helpers +defimpl Forge.Convertible, for: List do + alias Forge.Convertible + alias Forge.Convertible.Helpers def to_native(l, context_document) do case Helpers.apply(l, &Convertible.to_native/2, context_document) do @@ -152,9 +152,9 @@ defimpl Engine.Convertible, for: List do end end -defimpl Engine.Convertible, for: Map do - alias Engine.Convertible - alias Engine.Convertible.Helpers +defimpl Forge.Convertible, for: Map do + alias Forge.Convertible + alias Forge.Convertible.Helpers def to_native(map, context_document) do case Helpers.apply(map, &Convertible.to_native/2, context_document) do @@ -168,10 +168,10 @@ defimpl Engine.Convertible, for: Map do end end -defimpl Engine.Convertible, for: Any do - alias Engine.Convertible +defimpl Forge.Convertible, for: Any do + alias Forge.Convertible alias Forge.Document - alias Engine.Convertible.Helpers + alias Forge.Convertible.Helpers def to_native(%_struct_module{} = struct, context_document) do context_document = Document.Container.context_document(struct, context_document) diff --git a/engine/lib/engine/math.ex b/forge/lib/forge/math.ex similarity index 95% rename from engine/lib/engine/math.ex rename to forge/lib/forge/math.ex index b4d6612e..524829c6 100644 --- a/engine/lib/engine/math.ex +++ b/forge/lib/forge/math.ex @@ -1,4 +1,4 @@ -defmodule Engine.Math do +defmodule Forge.Math do @moduledoc """ Utilities related to mathematical operations """ diff --git a/engine/lib/engine/process_cache.ex b/forge/lib/forge/process_cache.ex similarity index 98% rename from engine/lib/engine/process_cache.ex rename to forge/lib/forge/process_cache.ex index 80ad3a56..69d02890 100644 --- a/engine/lib/engine/process_cache.ex +++ b/forge/lib/forge/process_cache.ex @@ -1,4 +1,4 @@ -defmodule Engine.ProcessCache do +defmodule Forge.ProcessCache do @moduledoc """ A simple cache with a timeout that lives in the process dictionary """ diff --git a/forge/lib/forge/project.ex b/forge/lib/forge/project.ex index 32063ff5..38c947b5 100644 --- a/forge/lib/forge/project.ex +++ b/forge/lib/forge/project.ex @@ -5,7 +5,7 @@ defmodule Forge.Project do This struct contains all the information required to build a project and interrogate its configuration, as well as business logic for how to change its attributes. """ - alias Engine.Document + alias Forge.Document defstruct root_uri: nil, mix_exs_uri: nil, @@ -28,7 +28,7 @@ defmodule Forge.Project do } @type error_with_message :: {:error, message} - @workspace_directory_name ".lexical" + @workspace_directory_name ".expert-lsp" # Public @spec new(Forge.uri()) :: t diff --git a/forge/mix.exs b/forge/mix.exs index 4404cdfc..6d18ed7b 100644 --- a/forge/mix.exs +++ b/forge/mix.exs @@ -22,7 +22,9 @@ defmodule Forge.MixProject do # Run "mix help deps" to learn about dependencies. defp deps do [ - {:sourceror, "~> 1.0"} + {:sourceror, "~> 1.0"}, + {:snowflake, "~> 1.0"} + # {:dep_from_hexpm, "~> 0.3.0"}, # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: "0.1.0"} ] diff --git a/forge/mix.lock b/forge/mix.lock new file mode 100644 index 00000000..bf7c5158 --- /dev/null +++ b/forge/mix.lock @@ -0,0 +1,4 @@ +%{ + "snowflake": {:hex, :snowflake, "1.0.4", "8433b4e04fbed19272c55e1b7de0f7a1ee1230b3ae31a813b616fd6ef279e87a", [:mix], [], "hexpm", "badb07ebb089a5cff737738297513db3962760b10fe2b158ae3bebf0b4d5be13"}, + "sourceror": {:hex, :sourceror, "1.7.1", "599d78f4cc2be7d55c9c4fd0a8d772fd0478e3a50e726697c20d13d02aa056d4", [:mix], [], "hexpm", "cd6f268fe29fa00afbc535e215158680a0662b357dc784646d7dff28ac65a0fc"}, +} From 6b5769cfd299eaacff4145c03d22133438b3cad6 Mon Sep 17 00:00:00 2001 From: Mitchell Hanberg Date: Sun, 5 Jan 2025 15:23:21 -0500 Subject: [PATCH 08/12] wip: copy in lots of Lexical.Server --- expert/lib/expert.ex | 85 ++- expert/lib/expert/application.ex | 9 +- expert/lib/expert/runtime/supervisor.ex | 26 - .../lexical.plugin.diagnostic.result.ex | 94 +++ expert/lib/lexical/server.ex | 198 +++++ expert/lib/lexical/server/application.ex | 32 + expert/lib/lexical/server/boot.ex | 149 ++++ .../server/code_intelligence/completion.ex | 369 ++++++++++ .../code_intelligence/completion/builder.ex | 188 +++++ .../completion/sort_scope.ex | 77 ++ .../completion/translatable.ex | 19 + .../translations/bitstring_option.ex | 25 + .../completion/translations/callable.ex | 222 ++++++ .../completion/translations/callback.ex | 103 +++ .../completion/translations/function.ex | 16 + .../completion/translations/macro.ex | 678 ++++++++++++++++++ .../completion/translations/map_field.ex | 27 + .../translations/module_attribute.ex | 178 +++++ .../translations/module_or_behaviour.ex | 145 ++++ .../completion/translations/struct.ex | 93 +++ .../completion/translations/struct_field.ex | 57 ++ .../completion/translations/typespec.ex | 12 + .../completion/translations/variable.ex | 18 + expert/lib/lexical/server/configuration.ex | 142 ++++ .../lexical/server/configuration/support.ex | 71 ++ expert/lib/lexical/server/dialyzer.ex | 5 + expert/lib/lexical/server/iex/helpers.ex | 267 +++++++ .../lib/lexical/server/project/diagnostics.ex | 107 +++ .../server/project/diagnostics/state.ex | 103 +++ .../lexical/server/project/intelligence.ex | 245 +++++++ expert/lib/lexical/server/project/node.ex | 108 +++ expert/lib/lexical/server/project/progress.ex | 46 ++ .../server/project/progress/percentage.ex | 67 ++ .../lexical/server/project/progress/state.ex | 106 +++ .../server/project/progress/support.ex | 42 ++ .../lexical/server/project/progress/value.ex | 45 ++ .../lexical/server/project/search_listener.ex | 55 ++ .../lib/lexical/server/project/supervisor.ex | 53 ++ .../server/provider/handlers/code_action.ex | 41 ++ .../server/provider/handlers/code_lens.ex | 58 ++ .../server/provider/handlers/commands.ex | 60 ++ .../server/provider/handlers/completion.ex | 37 + .../provider/handlers/document_symbols.ex | 58 ++ .../provider/handlers/find_references.ex | 26 + .../server/provider/handlers/formatting.ex | 24 + .../provider/handlers/go_to_definition.ex | 19 + .../lexical/server/provider/handlers/hover.ex | 237 ++++++ .../provider/handlers/workspace_symbol.ex | 57 ++ .../lib/lexical/server/provider/markdown.ex | 84 +++ expert/lib/lexical/server/state.ex | 312 ++++++++ expert/lib/lexical/server/task_queue.ex | 218 ++++++ expert/lib/lexical/server/transport.ex | 12 + expert/lib/lexical/server/transport/std_io.ex | 145 ++++ expert/lib/lexical/server/window.ex | 89 +++ 54 files changed, 5689 insertions(+), 70 deletions(-) delete mode 100644 expert/lib/expert/runtime/supervisor.ex create mode 100644 expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex create mode 100644 expert/lib/lexical/server.ex create mode 100644 expert/lib/lexical/server/application.ex create mode 100644 expert/lib/lexical/server/boot.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/builder.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/sort_scope.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translatable.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translations/function.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translations/struct.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex create mode 100644 expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex create mode 100644 expert/lib/lexical/server/configuration.ex create mode 100644 expert/lib/lexical/server/configuration/support.ex create mode 100644 expert/lib/lexical/server/dialyzer.ex create mode 100644 expert/lib/lexical/server/iex/helpers.ex create mode 100644 expert/lib/lexical/server/project/diagnostics.ex create mode 100644 expert/lib/lexical/server/project/diagnostics/state.ex create mode 100644 expert/lib/lexical/server/project/intelligence.ex create mode 100644 expert/lib/lexical/server/project/node.ex create mode 100644 expert/lib/lexical/server/project/progress.ex create mode 100644 expert/lib/lexical/server/project/progress/percentage.ex create mode 100644 expert/lib/lexical/server/project/progress/state.ex create mode 100644 expert/lib/lexical/server/project/progress/support.ex create mode 100644 expert/lib/lexical/server/project/progress/value.ex create mode 100644 expert/lib/lexical/server/project/search_listener.ex create mode 100644 expert/lib/lexical/server/project/supervisor.ex create mode 100644 expert/lib/lexical/server/provider/handlers/code_action.ex create mode 100644 expert/lib/lexical/server/provider/handlers/code_lens.ex create mode 100644 expert/lib/lexical/server/provider/handlers/commands.ex create mode 100644 expert/lib/lexical/server/provider/handlers/completion.ex create mode 100644 expert/lib/lexical/server/provider/handlers/document_symbols.ex create mode 100644 expert/lib/lexical/server/provider/handlers/find_references.ex create mode 100644 expert/lib/lexical/server/provider/handlers/formatting.ex create mode 100644 expert/lib/lexical/server/provider/handlers/go_to_definition.ex create mode 100644 expert/lib/lexical/server/provider/handlers/hover.ex create mode 100644 expert/lib/lexical/server/provider/handlers/workspace_symbol.ex create mode 100644 expert/lib/lexical/server/provider/markdown.ex create mode 100644 expert/lib/lexical/server/state.ex create mode 100644 expert/lib/lexical/server/task_queue.ex create mode 100644 expert/lib/lexical/server/transport.ex create mode 100644 expert/lib/lexical/server/transport/std_io.ex create mode 100644 expert/lib/lexical/server/window.ex diff --git a/expert/lib/expert.ex b/expert/lib/expert.ex index 79ab39e6..7401abe0 100644 --- a/expert/lib/expert.ex +++ b/expert/lib/expert.ex @@ -1,5 +1,17 @@ defmodule Expert do + alias GenLSP.Enumerations.CodeActionKind + alias GenLSP.Structures.CodeActionOptions use GenLSP + + alias GenLSP.Structures.WorkspaceFoldersServerCapabilities + alias GenLSP.Enumerations.TextDocumentSyncKind + alias GenLSP.Structures.SaveOptions + alias GenLSP.Structures.TextDocumentSyncOptions + alias GenLSP.Structures.ServerCapabilities + alias GenLSP.Structures.InitializeResult + alias GenLSP.Structures.InitializeParams + alias GenLSP.Requests.Initialize + require Logger require Expert.Runtime @@ -7,9 +19,7 @@ defmodule Expert do def start_link(args) do {args, opts} = - Keyword.split(args, [ - :dynamic_supervisor - ]) + Keyword.split(args, [:dynamic_supervisor]) GenLSP.start_link(__MODULE__, args, opts) end @@ -28,8 +38,8 @@ defmodule Expert do @impl true def handle_request( - %GenLSP.Requests.Initialize{ - params: %GenLSP.Structures.InitializeParams{ + %Initialize{ + params: %InitializeParams{ root_uri: root_uri, workspace_folders: workspace_folders, capabilities: caps @@ -37,48 +47,37 @@ defmodule Expert do }, lsp ) do - parent = self() - name = Path.basename(root_uri) - - working_dir = URI.parse(root_uri).path - - DynamicSupervisor.start_child( - lsp.assigns.dynamic_supervisor, - {Expert.Runtime.Supervisor, - path: Path.join(working_dir, ".expert-lsp"), - name: name, - lsp: lsp, - lsp_pid: parent, - runtime: [ - working_dir: working_dir, - uri: root_uri, - on_initialized: fn status -> - if status == :ready do - msg = {:runtime_ready, name, self()} - - Process.send(parent, msg, []) - else - send(parent, {:runtime_failed, name, status}) - end - end - ]} - ) - {:reply, - %GenLSP.Structures.InitializeResult{ - capabilities: %GenLSP.Structures.ServerCapabilities{ - text_document_sync: %GenLSP.Structures.TextDocumentSyncOptions{ + %InitializeResult{ + capabilities: %ServerCapabilities{ + text_document_sync: %TextDocumentSyncOptions{ open_close: true, - save: %GenLSP.Structures.SaveOptions{include_text: true}, - change: GenLSP.Enumerations.TextDocumentSyncKind.incremental() + save: %SaveOptions{include_text: true}, + change: TextDocumentSyncKind.incremental() + }, + code_action_provider: %CodeActionOptions{ + code_action_kinds: [ + # TODO(mhanberg): add code actions from Next LS + CodeActionKind.quick_fix(), + CodeActionKind.source_organize_imports() + ] }, + code_lens_provider: %GenLSP.Structures.CodeLensOptions{ + resolve_provider: false + }, + completion_provider: %GenLSP.Structures.CompletionOptions{ + trigger_characters: [".", "@", "&", "%", "^", ":", "!", "-", "~"] + }, + definition_provider: true, document_symbol_provider: true, - workspace: %{ - workspace_folders: %GenLSP.Structures.WorkspaceFoldersServerCapabilities{ - supported: true, - change_notifications: true - } - } + document_formatting_provider: true, + execute_command_provider: %GenLSP.Structures.ExecuteCommandOptions{ + # TODO(mhanberg): add commands from Next LS + commands: ["Reindex"] + }, + hover_provider: true, + references_provider: true, + workspace_symbol_provider: true }, server_info: %{name: "Expert"} }, diff --git a/expert/lib/expert/application.ex b/expert/lib/expert/application.ex index 41b8a763..f4cdd0a3 100644 --- a/expert/lib/expert/application.ex +++ b/expert/lib/expert/application.ex @@ -5,6 +5,7 @@ defmodule Expert.Application do use Application + @impl true def start(_type, _args) do case System.cmd("epmd", ["-daemon"], stderr_to_stdout: true) do @@ -19,7 +20,13 @@ defmodule Expert.Application do Node.start(:"expert-#{System.system_time()}", :shortnames) - children = [Expert.LSPSupervisor] + children = [ + document_store_child_spec(), + Expert.LSPSupervisor + {DynamicSupervisor, Server.Project.Supervisor.options()}, + {Task.Supervisor, name: TaskQueue.task_supervisor_name()}, + TaskQueue, + ] # See https://hexdocs.pm/elixir/Supervisor.html # for other strategies and supported options diff --git a/expert/lib/expert/runtime/supervisor.ex b/expert/lib/expert/runtime/supervisor.ex deleted file mode 100644 index 5c6abcfe..00000000 --- a/expert/lib/expert/runtime/supervisor.ex +++ /dev/null @@ -1,26 +0,0 @@ -defmodule Expert.Runtime.Supervisor do - @moduledoc false - - use Supervisor - - def start_link(init_arg) do - Supervisor.start_link(__MODULE__, init_arg) - end - - @impl true - def init(init_arg) do - name = init_arg[:name] - lsp_pid = init_arg[:lsp_pid] - hidden_folder = init_arg[:path] - File.mkdir_p!(hidden_folder) - File.write!(Path.join(hidden_folder, ".gitignore"), "*\n") - - children = [ - {Expert.Runtime, - init_arg[:runtime] ++ - [name: name, parent: lsp_pid, lsp_pid: lsp_pid]} - ] - - Supervisor.init(children, strategy: :one_for_one) - end -end diff --git a/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex b/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex new file mode 100644 index 00000000..e6251213 --- /dev/null +++ b/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex @@ -0,0 +1,94 @@ +defimpl Lexical.Convertible, for: Lexical.Plugin.V1.Diagnostic.Result do + alias Lexical.Document + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.Math + alias Lexical.Plugin.V1.Diagnostic + alias Lexical.Protocol.Conversions + alias Lexical.Protocol.Types + alias Lexical.Text + + def to_lsp(%Diagnostic.Result{} = diagnostic) do + with {:ok, lsp_range} <- lsp_range(diagnostic) do + proto_diagnostic = %Types.Diagnostic{ + message: diagnostic.message, + range: lsp_range, + severity: diagnostic.severity, + source: diagnostic.source + } + + {:ok, proto_diagnostic} + end + end + + def to_native(%Diagnostic.Result{} = diagnostic, _) do + {:ok, diagnostic} + end + + defp lsp_range(%Diagnostic.Result{position: %Position{} = position}) do + with {:ok, lsp_start_pos} <- Conversions.to_lsp(position) do + range = + Types.Range.new( + start: lsp_start_pos, + end: Types.Position.new(line: lsp_start_pos.line + 1, character: 0) + ) + + {:ok, range} + end + end + + defp lsp_range(%Diagnostic.Result{position: %Range{} = range}) do + Conversions.to_lsp(range) + end + + defp lsp_range(%Diagnostic.Result{uri: uri} = diagnostic) when is_binary(uri) do + with {:ok, document} <- Document.Store.open_temporary(uri) do + position_to_range(document, diagnostic.position) + end + end + + defp lsp_range(%Diagnostic.Result{}) do + {:error, :no_uri} + end + + defp position_to_range(%Document{} = document, {start_line, start_column, end_line, end_column}) do + start_pos = Position.new(document, start_line, max(start_column, 1)) + end_pos = Position.new(document, end_line, max(end_column, 1)) + + range = Range.new(start_pos, end_pos) + Conversions.to_lsp(range) + end + + defp position_to_range(%Document{} = document, {line_number, column}) do + column = max(column, 1) + + document + |> to_lexical_range(line_number, column) + |> Conversions.to_lsp() + end + + defp position_to_range(document, line_number) when is_integer(line_number) do + line_number = Math.clamp(line_number, 1, Document.size(document)) + + with {:ok, line_text} <- Document.fetch_text_at(document, line_number) do + column = Text.count_leading_spaces(line_text) + 1 + + document + |> to_lexical_range(line_number, column) + |> Conversions.to_lsp() + end + end + + defp position_to_range(document, nil) do + position_to_range(document, 1) + end + + defp to_lexical_range(%Document{} = document, line_number, column) do + line_number = Math.clamp(line_number, 1, Document.size(document) + 1) + + Range.new( + Position.new(document, line_number, column), + Position.new(document, line_number + 1, 1) + ) + end +end diff --git a/expert/lib/lexical/server.ex b/expert/lib/lexical/server.ex new file mode 100644 index 00000000..c954ac2a --- /dev/null +++ b/expert/lib/lexical/server.ex @@ -0,0 +1,198 @@ +# defmodule Expert do +# alias Lexical.Proto.Convert +# alias Lexical.Protocol.Notifications +# alias Lexical.Protocol.Requests +# alias Expert.Provider.Handlers +# alias Expert.State +# alias Expert.TaskQueue +# +# require Logger +# +# use GenServer +# +# @server_specific_messages [ +# Notifications.DidChange, +# Notifications.DidChangeConfiguration, +# Notifications.DidChangeWatchedFiles, +# Notifications.DidClose, +# Notifications.DidOpen, +# Notifications.DidSave, +# Notifications.Exit, +# Notifications.Initialized, +# Requests.Shutdown +# ] +# +# @dialyzer {:nowarn_function, apply_to_state: 2} +# +# @spec server_request( +# Requests.request(), +# (Requests.request(), {:ok, any()} | {:error, term()} -> term()) +# ) :: :ok +# def server_request(request, on_response) when is_function(on_response, 2) do +# GenServer.call(__MODULE__, {:server_request, request, on_response}) +# end +# +# @spec server_request(Requests.request()) :: :ok +# def server_request(request) do +# server_request(request, fn _, _ -> :ok end) +# end +# +# def start_link(_) do +# GenServer.start_link(__MODULE__, [], name: __MODULE__) +# end +# +# def protocol_message(message) do +# GenServer.cast(__MODULE__, {:protocol_message, message}) +# end +# +# def init(_) do +# {:ok, State.new()} +# end +# +# def handle_call({:server_request, request, on_response}, _from, %State{} = state) do +# new_state = State.add_request(state, request, on_response) +# {:reply, :ok, new_state} +# end +# +# def handle_cast({:protocol_message, message}, %State{} = state) do +# new_state = +# case handle_message(message, state) do +# {:ok, new_state} -> +# new_state +# +# error -> +# Logger.error( +# "Could not handle message #{inspect(message.__struct__)} #{inspect(error)}" +# ) +# +# state +# end +# +# {:noreply, new_state} +# end +# +# def handle_cast(other, %State{} = state) do +# Logger.info("got other: #{inspect(other)}") +# {:noreply, state} +# end +# +# def handle_info(:default_config, %State{configuration: nil} = state) do +# Logger.warning( +# "Did not receive workspace/didChangeConfiguration notification after 5 seconds. " <> +# "Using default settings." +# ) +# +# {:ok, config} = State.default_configuration(state) +# {:noreply, %State{state | configuration: config}} +# end +# +# def handle_info(:default_config, %State{} = state) do +# {:noreply, state} +# end +# +# def handle_message(%Requests.Initialize{} = initialize, %State{} = state) do +# Process.send_after(self(), :default_config, :timer.seconds(5)) +# +# case State.initialize(state, initialize) do +# {:ok, _state} = success -> +# success +# +# error -> +# {error, state} +# end +# end +# +# def handle_message(%Requests.Cancel{} = cancel_request, %State{} = state) do +# TaskQueue.cancel(cancel_request) +# {:ok, state} +# end +# +# def handle_message(%Notifications.Cancel{} = cancel_notification, %State{} = state) do +# TaskQueue.cancel(cancel_notification) +# {:ok, state} +# end +# +# def handle_message(%message_module{} = message, %State{} = state) +# when message_module in @server_specific_messages do +# case apply_to_state(state, message) do +# {:ok, _} = success -> +# success +# +# error -> +# Logger.error("Failed to handle #{message.__struct__}, #{inspect(error)}") +# end +# end +# +# def handle_message(nil, %State{} = state) do +# # NOTE: This deals with the response after a request is requested by the server, +# # such as the response of `CreateWorkDoneProgress`. +# {:ok, state} +# end +# +# def handle_message(%_{} = request, %State{} = state) do +# with {:ok, handler} <- fetch_handler(request), +# {:ok, req} <- Convert.to_native(request) do +# TaskQueue.add(request.id, {handler, :handle, [req, state.configuration]}) +# else +# {:error, {:unhandled, _}} -> +# Logger.info("Unhandled request: #{request.method}") +# +# _ -> +# :ok +# end +# +# {:ok, state} +# end +# +# def handle_message(%{} = response, %State{} = state) do +# new_state = State.finish_request(state, response) +# +# {:ok, new_state} +# end +# +# defp apply_to_state(%State{} = state, %{} = request_or_notification) do +# case State.apply(state, request_or_notification) do +# {:ok, new_state} -> {:ok, new_state} +# :ok -> {:ok, state} +# error -> {error, state} +# end +# end +# +# # credo:disable-for-next-line Credo.Check.Refactor.CyclomaticComplexity +# defp fetch_handler(%_{} = request) do +# case request do +# %Requests.FindReferences{} -> +# {:ok, Handlers.FindReferences} +# +# %Requests.Formatting{} -> +# {:ok, Handlers.Formatting} +# +# %Requests.CodeAction{} -> +# {:ok, Handlers.CodeAction} +# +# %Requests.CodeLens{} -> +# {:ok, Handlers.CodeLens} +# +# %Requests.Completion{} -> +# {:ok, Handlers.Completion} +# +# %Requests.GoToDefinition{} -> +# {:ok, Handlers.GoToDefinition} +# +# %Requests.Hover{} -> +# {:ok, Handlers.Hover} +# +# %Requests.ExecuteCommand{} -> +# {:ok, Handlers.Commands} +# +# %Requests.DocumentSymbols{} -> +# {:ok, Handlers.DocumentSymbols} +# +# %Requests.WorkspaceSymbol{} -> +# {:ok, Handlers.WorkspaceSymbol} +# +# %request_module{} -> +# {:error, {:unhandled, request_module}} +# end +# end +# end diff --git a/expert/lib/lexical/server/application.ex b/expert/lib/lexical/server/application.ex new file mode 100644 index 00000000..bff7d20d --- /dev/null +++ b/expert/lib/lexical/server/application.ex @@ -0,0 +1,32 @@ +defmodule Expert.Application do + # See https://hexdocs.pm/elixir/Application.html + # for more information on OTP Applications + @moduledoc false + + alias Lexical.Document + alias Expert + alias Expert.TaskQueue + alias Expert.Transport + + use Application + + @impl true + def start(_type, _args) do + children = [ + document_store_child_spec(), + Server, + {DynamicSupervisor, Server.Project.Supervisor.options()}, + {Task.Supervisor, name: TaskQueue.task_supervisor_name()}, + TaskQueue, + {Transport.StdIO, [:standard_io, &Server.protocol_message/1]} + ] + + opts = [strategy: :one_for_one, name: Server.Supervisor] + Supervisor.start_link(children, opts) + end + + @doc false + def document_store_child_spec do + {Document.Store, derive: [analysis: &Lexical.Ast.analyze/1]} + end +end diff --git a/expert/lib/lexical/server/boot.ex b/expert/lib/lexical/server/boot.ex new file mode 100644 index 00000000..7cf5f707 --- /dev/null +++ b/expert/lib/lexical/server/boot.ex @@ -0,0 +1,149 @@ +defmodule Expert.Boot do + @moduledoc """ + This module is called when the server starts by the start script. + + Packaging will ensure that config.exs and runtime.exs will be visible to the `:code` module + """ + alias Future.Code + alias Lexical.VM.Versions + require Logger + + # halt/1 will generate a "no local return" error, which is exactly right, but that's it's _job_ + @dialyzer {:nowarn_function, halt: 1} + + @env Mix.env() + @target Mix.target() + @dep_apps Enum.map(Mix.Dep.cached(), & &1.app) + + def start do + {:ok, _} = Application.ensure_all_started(:mix) + + Application.stop(:logger) + load_config() + Application.ensure_all_started(:logger) + + Enum.each(@dep_apps, &load_app_modules/1) + + case detect_errors() do + [] -> + :ok + + errors -> + errors + |> Enum.join("\n\n") + |> halt() + end + + Application.ensure_all_started(:server) + end + + @doc false + def detect_errors do + versioning_errors() + end + + defp load_config do + config = read_config("config.exs") + runtime = read_config("runtime.exs") + merged_config = Config.Reader.merge(config, runtime) + apply_config(merged_config) + end + + defp apply_config(configs) do + for {app_name, keywords} <- configs, + {config_key, config_value} <- keywords do + Application.put_env(app_name, config_key, config_value) + end + end + + defp read_config(file_name) do + case where_is_file(String.to_charlist(file_name)) do + {:ok, path} -> + Config.Reader.read!(path, env: @env, target: @target) + + _ -> + [] + end + end + + defp where_is_file(file_name) do + case :code.where_is_file(file_name) do + :non_existing -> + :error + + path -> + {:ok, List.to_string(path)} + end + end + + defp load_app_modules(app_name) do + Application.ensure_loaded(app_name) + modules = Application.spec(app_name, :modules) + Code.ensure_all_loaded!(modules) + end + + @allowed_elixir %{ + "1.13.0" => ">= 1.13.0", + "1.14.0" => ">= 1.14.0", + "1.15.0" => ">= 1.15.3", + "1.16.0" => ">= 1.16.0", + "1.17.0-rc" => ">= 1.17.0-rc", + "1.17.0" => ">= 1.17.0" + } + @allowed_erlang %{ + "24" => ">= 24.3.4", + "25" => ">= 25.0.0", + "26" => ">= 26.0.2", + "27" => ">= 27.0.0" + } + + defp versioning_errors do + versions = Versions.to_versions(Versions.current()) + + elixir_base = to_string(%Version{versions.elixir | patch: 0}) + erlang_base = to_string(versions.erlang.major) + + detected_elixir_range = Map.get(@allowed_elixir, elixir_base, false) + detected_erlang_range = Map.get(@allowed_erlang, erlang_base, false) + + elixir_ok? = detected_elixir_range && Version.match?(versions.elixir, detected_elixir_range) + erlang_ok? = detected_erlang_range && Version.match?(versions.erlang, detected_erlang_range) + + errors = [ + unless elixir_ok? do + """ + FATAL: Lexical is not compatible with Elixir #{versions.elixir} + + Lexical is compatible with the following versions of Elixir: + + #{format_allowed_versions(@allowed_elixir)} + """ + end, + unless erlang_ok? do + """ + FATAL: Lexical is not compatible with Erlang/OTP #{versions.erlang} + + Lexical is compatible with the following versions of Erlang/OTP: + + #{format_allowed_versions(@allowed_erlang)} + """ + end + ] + + Enum.filter(errors, &Function.identity/1) + end + + defp format_allowed_versions(%{} = versions) do + versions + |> Map.values() + |> Enum.sort() + |> Enum.map_join("\n", fn range -> " #{range}" end) + end + + defp halt(message) do + Mix.Shell.IO.error(message) + Logger.emergency(message) + Logger.flush() + System.halt() + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion.ex b/expert/lib/lexical/server/code_intelligence/completion.ex new file mode 100644 index 00000000..2198a35e --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion.ex @@ -0,0 +1,369 @@ +defmodule Expert.CodeIntelligence.Completion do + alias Future.Code, as: Code + alias Lexical.Ast.Analysis + alias Lexical.Ast.Env + alias Lexical.Document.Position + alias Lexical.Project + alias Lexical.Protocol.Types.Completion + alias Lexical.Protocol.Types.InsertTextFormat + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Completion.Candidate + alias Expert.CodeIntelligence.Completion.Builder + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.Configuration + alias Expert.Project.Intelligence + alias Mix.Tasks.Namespace + + require InsertTextFormat + require Logger + + @lexical_deps Enum.map([:lexical | Mix.Project.deps_apps()], &Atom.to_string/1) + + @lexical_dep_modules Enum.map(@lexical_deps, &Macro.camelize/1) + + def trigger_characters do + [".", "@", "&", "%", "^", ":", "!", "-", "~"] + end + + @spec complete(Project.t(), Analysis.t(), Position.t(), Completion.Context.t()) :: + Completion.List.t() + def complete( + %Project{} = project, + %Analysis{} = analysis, + %Position{} = position, + %Completion.Context{} = context + ) do + case Env.new(project, analysis, position) do + {:ok, env} -> + completions = completions(project, env, context) + log_candidates(completions) + maybe_to_completion_list(completions) + + {:error, _} = error -> + Logger.error("Failed to build completion env #{inspect(error)}") + maybe_to_completion_list() + end + end + + defp log_candidates(candidates) do + log_iolist = + Enum.reduce(candidates, ["Emitting Completions: ["], fn %Completion.Item{} = completion, + acc -> + name = Map.get(completion, :name) || Map.get(completion, :label) + kind = completion |> Map.get(:kind, :unknown) |> to_string() + + [acc, [kind, ":", name], " "] + end) + + Logger.info([log_iolist, "]"]) + end + + defp completions(%Project{} = project, %Env{} = env, %Completion.Context{} = context) do + prefix_tokens = Env.prefix_tokens(env, 1) + + cond do + prefix_tokens == [] or not should_emit_completions?(env) -> + [] + + should_emit_do_end_snippet?(env) -> + do_end_snippet = "do\n $0\nend" + + env + |> Builder.snippet( + do_end_snippet, + label: "do/end block", + filter_text: "do" + ) + |> List.wrap() + + Env.in_context?(env, :struct_field_key) -> + project + |> RemoteControl.Api.complete_struct_fields(env.analysis, env.position) + |> Enum.map(&Translatable.translate(&1, Builder, env)) + + true -> + project + |> RemoteControl.Api.complete(env) + |> to_completion_items(project, env, context) + end + end + + defp should_emit_completions?(%Env{} = env) do + if inside_comment?(env) or inside_string?(env) do + false + else + always_emit_completions?() or has_meaningful_completions?(env) + end + end + + defp always_emit_completions? do + # If VS Code receives an empty completion list, it will never issue + # a new request, even if `is_incomplete: true` is specified. + # https://github.com/lexical-lsp/lexical/issues/400 + Configuration.get().client_name == "Visual Studio Code" + end + + defp has_meaningful_completions?(%Env{} = env) do + case Code.Fragment.cursor_context(env.prefix) do + :none -> + false + + {:unquoted_atom, name} -> + length(name) > 1 + + {:local_or_var, name} -> + local_length = length(name) + surround_begin = max(1, env.position.character - local_length) + + local_length > 1 or has_surround_context?(env.prefix, 1, surround_begin) + + _ -> + true + end + end + + defp inside_comment?(env) do + Env.in_context?(env, :comment) + end + + defp inside_string?(env) do + Env.in_context?(env, :string) + end + + defp has_surround_context?(fragment, line, column) + when is_binary(fragment) and line >= 1 and column >= 1 do + Code.Fragment.surround_context(fragment, {line, column}) != :none + end + + # We emit a do/end snippet if the prefix token is the do operator or 'd', and + # there is a space before the token preceding it on the same line. This + # handles situations like `@do|` where a do/end snippet would be invalid. + defguardp valid_do_prefix(kind, value) + when (kind === :identifier and value === ~c"d") or + (kind === :operator and value === :do) + + defguardp space_before_preceding_token(do_col, preceding_col) + when do_col - preceding_col > 1 + + defp should_emit_do_end_snippet?(%Env{} = env) do + prefix_tokens = Env.prefix_tokens(env, 2) + + valid_prefix? = + match?( + [{kind, value, {line, do_col}}, {_, _, {line, preceding_col}}] + when space_before_preceding_token(do_col, preceding_col) and + valid_do_prefix(kind, value), + prefix_tokens + ) + + valid_prefix? and Env.empty?(env.suffix) + end + + defp to_completion_items( + local_completions, + %Project{} = project, + %Env{} = env, + %Completion.Context{} = context + ) do + debug_local_completions(local_completions) + + for result <- local_completions, + displayable?(project, result), + applies_to_context?(project, result, context), + applies_to_env?(env, result), + %Completion.Item{} = item <- to_completion_item(result, env) do + item + end + end + + defp debug_local_completions(completions) do + completions_by_type = + Enum.group_by(completions, fn %candidate_module{} -> + candidate_module + |> Atom.to_string() + |> String.split(".") + |> List.last() + |> String.downcase() + end) + + log_iodata = + Enum.reduce(completions_by_type, ["Local completions are: ["], fn {type, completions}, + acc -> + names = + Enum.map_join(completions, ", ", fn candidate -> + Map.get(candidate, :name) || Map.get(candidate, :detail) + end) + + [acc, [type, ": (", names], ") "] + end) + + Logger.info([log_iodata, "]"]) + end + + defp to_completion_item(candidate, env) do + candidate + |> Translatable.translate(Builder, env) + |> List.wrap() + end + + defp displayable?(%Project{} = project, result) do + suggested_module = + case result do + %_{full_name: full_name} when is_binary(full_name) -> full_name + %_{origin: origin} when is_binary(origin) -> origin + _ -> "" + end + + cond do + Namespace.Module.prefixed?(suggested_module) -> + false + + # If we're working on the dependency, we should include it! + Project.name(project) in @lexical_deps -> + true + + true -> + Enum.reduce_while(@lexical_dep_modules, true, fn module, _ -> + if String.starts_with?(suggested_module, module) do + {:halt, false} + else + {:cont, true} + end + end) + end + end + + defp applies_to_env?(%Env{} = env, %struct_module{} = result) do + cond do + Env.in_context?(env, :struct_reference) -> + struct_reference_completion?(result, env) + + Env.in_context?(env, :bitstring) -> + struct_module in [Candidate.BitstringOption, Candidate.Variable] + + Env.in_context?(env, :alias) -> + struct_module in [ + Candidate.Behaviour, + Candidate.Module, + Candidate.Protocol, + Candidate.Struct + ] + + Env.in_context?(env, :use) -> + # only allow modules that define __using__ in a use statement + usable?(env, result) + + Env.in_context?(env, :impl) -> + # only allow behaviour modules after @impl + behaviour?(env, result) + + Env.in_context?(env, :spec) or Env.in_context?(env, :type) -> + typespec_or_type_candidate?(result, env) + + true -> + struct_module != Candidate.Typespec + end + end + + defp usable?(%Env{} = env, completion) do + # returns true if the given completion is or is a parent of + # a module that defines __using__ + case completion do + %{full_name: full_name} -> + with_prefix = + RemoteControl.Api.modules_with_prefix( + env.project, + full_name, + {Kernel, :macro_exported?, [:__using__, 1]} + ) + + not Enum.empty?(with_prefix) + + _ -> + false + end + end + + defp behaviour?(%Env{} = env, completion) do + # returns true if the given completion is or is a parent of + # a module that is a behaviour + + case completion do + %{full_name: full_name} -> + with_prefix = + RemoteControl.Api.modules_with_prefix( + env.project, + full_name, + {Kernel, :function_exported?, [:behaviour_info, 1]} + ) + + not Enum.empty?(with_prefix) + + _ -> + false + end + end + + defp struct_reference_completion?(%Candidate.Struct{}, _) do + true + end + + defp struct_reference_completion?(%Candidate.Module{} = module, %Env{} = env) do + Intelligence.defines_struct?(env.project, module.full_name, to: :great_grandchild) + end + + defp struct_reference_completion?(%Candidate.Macro{name: "__MODULE__"}, _) do + true + end + + defp struct_reference_completion?(_, _) do + false + end + + defp typespec_or_type_candidate?(%struct_module{}, _) + when struct_module in [Candidate.Module, Candidate.Typespec, Candidate.ModuleAttribute] do + true + end + + defp typespec_or_type_candidate?(%Candidate.Function{} = function, %Env{} = env) do + case RemoteControl.Api.expand_alias(env.project, [:__MODULE__], env.analysis, env.position) do + {:ok, expanded} -> + expanded == function.origin + + _error -> + false + end + end + + defp typespec_or_type_candidate?(_, _) do + false + end + + defp applies_to_context?(%Project{} = project, result, %Completion.Context{ + trigger_kind: :trigger_character, + trigger_character: "%" + }) do + case result do + %Candidate.Module{} = result -> + Intelligence.defines_struct?(project, result.full_name, from: :child, to: :child) + + %Candidate.Struct{} -> + true + + _other -> + false + end + end + + defp applies_to_context?(_project, _result, _context) do + true + end + + defp maybe_to_completion_list(items \\ []) + + defp maybe_to_completion_list([]) do + Completion.List.new(items: [], is_incomplete: true) + end + + defp maybe_to_completion_list(items), do: items +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/builder.ex b/expert/lib/lexical/server/code_intelligence/completion/builder.ex new file mode 100644 index 00000000..35f0e6e3 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/builder.ex @@ -0,0 +1,188 @@ +defmodule Expert.CodeIntelligence.Completion.Builder do + @moduledoc """ + Completion builder. + + For broader compatibility and control, this builder always creates text + edits, as opposed to simple text insertions. This allows the replacement + range to be adjusted based on the kind of completion. + + When completions are built using `plain_text/3` or `snippet/3`, the + replacement range will be determined by the preceding token. + """ + + alias Future.Code, as: Code + alias Lexical.Ast.Env + alias Lexical.Document + alias Lexical.Document.Edit + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.Protocol.Types.Completion + alias Lexical.Protocol.Types.Markup.Content + alias Expert.CodeIntelligence.Completion.SortScope + + @doc "Fields found in `t:Lexical.Protocol.Types.Completion.Item.t()`" + @type item_opts :: keyword() + + @type t :: module() + + @type line_range :: {start_character :: pos_integer, end_character :: pos_integer} + + @spec snippet(Env.t(), String.t(), item_opts) :: Completion.Item.t() + def snippet(%Env{} = env, text, options \\ []) do + range = prefix_range(env) + text_edit_snippet(env, text, range, options) + end + + @spec plain_text(Env.t(), String.t(), item_opts) :: Completion.Item.t() + def plain_text(%Env{} = env, text, options \\ []) do + range = prefix_range(env) + text_edit(env, text, range, options) + end + + @spec text_edit(Env.t(), String.t(), line_range, item_opts) :: Completion.Item.t() + def text_edit(%Env{} = env, text, {start_char, end_char}, options \\ []) do + line_number = env.position.line + + range = + Range.new( + Position.new(env.document, line_number, start_char), + Position.new(env.document, line_number, end_char) + ) + + edits = Document.Changes.new(env.document, Edit.new(text, range)) + + options + |> Keyword.put(:text_edit, edits) + |> Completion.Item.new() + |> markdown_docs() + |> set_sort_scope(SortScope.default()) + end + + @spec text_edit_snippet(Env.t(), String.t(), line_range, item_opts) :: Completion.Item.t() + def text_edit_snippet(%Env{} = env, text, {start_char, end_char}, options \\ []) do + snippet = String.trim_trailing(text, "\n") + line_number = env.position.line + + range = + Range.new( + Position.new(env.document, line_number, start_char), + Position.new(env.document, line_number, end_char) + ) + + edits = Document.Changes.new(env.document, Edit.new(snippet, range)) + + options + |> Keyword.put(:text_edit, edits) + |> Keyword.put(:insert_text_format, :snippet) + |> Completion.Item.new() + |> markdown_docs() + |> set_sort_scope(SortScope.default()) + end + + @spec fallback(any, any) :: any + def fallback(nil, fallback), do: fallback + def fallback("", fallback), do: fallback + def fallback(detail, _), do: detail + + @spec set_sort_scope(Completion.Item.t(), sort_scope :: String.t()) :: Completion.Item.t() + def set_sort_scope(item, default \\ SortScope.default()) + + def set_sort_scope(%Completion.Item{} = item, sort_scope) + when is_binary(sort_scope) do + stripped_sort_text = + item.sort_text + |> fallback(item.label) + |> strip_sort_text() + + sort_text = "0#{sort_scope}_#{stripped_sort_text}" + %Completion.Item{item | sort_text: sort_text} + end + + # private + + defp prefix_range(%Env{} = env) do + end_char = env.position.character + start_char = end_char - prefix_length(env) + {start_char, end_char} + end + + # credo:disable-for-next-line Credo.Check.Refactor.CyclomaticComplexity + defp prefix_length(%Env{} = env) do + case Code.Fragment.cursor_context(env.prefix) do + {:alias, alias_charlist} -> + alias_charlist + |> :string.split(~c".", :all) + |> List.last() + |> length() + + {:alias, {:local_or_var, _}, alias_charlist} -> + length(alias_charlist) + + {:alias, {:module_attribute, _}, alias_charlist} -> + length(alias_charlist) + + {:dot, _inside_dot, charlist} -> + length(charlist) + + {:dot_arity, _inside_dot, charlist} -> + length(charlist) + + {:dot_call, _inside_dot, _charlist} -> + 0 + + :expr -> + String.length(env.prefix) + + {:local_or_var, local} -> + length(local) + + {:local_arity, local} -> + length(local) + + {:local_call, call} -> + length(call) + + {:module_attribute, attr} -> + length(attr) + + {:operator, operator} -> + length(operator) + + {:operator_arity, _} -> + 0 + + {:operator_call, _} -> + 0 + + {:sigil, sigil} -> + # The sigil charlist doesn't include the leading `~` + length(sigil) + 1 + + {:struct, struct} -> + length(struct) + + :none -> + 0 + + {:unquoted_atom, atom} -> + # add one to include the leading colon, which isn't included + # in the atom charlist + length(atom) + 1 + end + end + + @sort_prefix_re ~r/^[0-9_]+/ + defp strip_sort_text(sort_text) do + String.replace(sort_text, @sort_prefix_re, "") + end + + defp markdown_docs(%Completion.Item{} = item) do + case item.documentation do + doc when is_binary(doc) -> + %{item | documentation: %Content{kind: :markdown, value: doc}} + + _ -> + item + end + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/sort_scope.ex b/expert/lib/lexical/server/code_intelligence/completion/sort_scope.ex new file mode 100644 index 00000000..a2bc44db --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/sort_scope.ex @@ -0,0 +1,77 @@ +defmodule Expert.CodeIntelligence.Completion.SortScope do + @moduledoc """ + Enumerated categories for sorting completion items. + + The following options are available for all categories, spare variables + which cannot be deprecated. + * `deprecated?` - Indicates the completion is for a deprecated declaration. + Defaults to `false`. + + * `local_priority` - An integer from 0-9 highest-to-lowest for + prioritizing/sorting results within a given scope. Defaults to `1`. + """ + + @doc """ + Intended for module completions, such as `Lexical.` -> `Lexical.Completion`. + """ + def module(local_priority \\ 1) do + "0" <> "0" <> local_priority(local_priority) + end + + @doc """ + Intended for variables, which are always local in scope. + """ + def variable(local_priority \\ 1) do + "1" <> "0" <> local_priority(local_priority) + end + + @doc """ + Intended for declarations (functions and macros) defined in the immediate + module, or inherited from invoking `use`. + """ + def local(deprecated? \\ false, local_priority \\ 1) do + "2" <> extra_order_fields(deprecated?, local_priority) + end + + @doc """ + Intended for delcarations defined in other modules than the immediate scope, + either from one's project, dependencies, or the standard library. + """ + def remote(deprecated? \\ false, local_priority \\ 1) do + "3" <> extra_order_fields(deprecated?, local_priority) + end + + @doc """ + Intended for declarations available without aliasing, namely those in + `Kernel` and `Kernel.SpecialForms`. + """ + def global(deprecated? \\ false, local_priority \\ 1) do + "4" <> extra_order_fields(deprecated?, local_priority) + end + + @doc """ + Aspirationally for declarations that could be auto-aliased into the user's + immediate module (not yet a feature of Lexical). + """ + def auto(deprecated? \\ false, local_priority \\ 1) do + "5" <> extra_order_fields(deprecated?, local_priority) + end + + @doc """ + Sorting scope applied to completions that without any sorting scope applied. + """ + def default(deprecated? \\ false, local_priority \\ 1) do + "9" <> extra_order_fields(deprecated?, local_priority) + end + + defp extra_order_fields(deprecated?, local_priority) do + deprecated(deprecated?) <> local_priority(local_priority) + end + + defp deprecated(false), do: "0" + defp deprecated(true), do: "1" + + defp local_priority(x) when x in 0..9 do + Integer.to_string(x) + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translatable.ex b/expert/lib/lexical/server/code_intelligence/completion/translatable.ex new file mode 100644 index 00000000..f6d75b4c --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translatable.ex @@ -0,0 +1,19 @@ +defprotocol Expert.CodeIntelligence.Completion.Translatable do + alias Lexical.Ast.Env + alias Lexical.Protocol.Types.Completion + alias Expert.CodeIntelligence.Completion.Builder + + @type t :: any() + + @type translated :: [Completion.Item.t()] | Completion.Item.t() | :skip + + @fallback_to_any true + @spec translate(t, Builder.t(), Env.t()) :: translated + def translate(item, builder, env) +end + +defimpl Expert.CodeIntelligence.Completion.Translatable, for: Any do + def translate(_any, _builder, _environment) do + :skip + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex new file mode 100644 index 00000000..4adb2f48 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex @@ -0,0 +1,25 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.BitstringOption do + alias Lexical.Ast.Env + alias Lexical.RemoteControl.Completion.Candidate + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations + + require Logger + + defimpl Translatable, for: Candidate.BitstringOption do + def translate(option, builder, %Env{} = env) do + Translations.BitstringOption.translate(option, builder, env) + end + end + + def translate(%Candidate.BitstringOption{} = option, builder, %Env{} = env) do + env + |> builder.plain_text(option.name, + filter_text: option.name, + kind: :unit, + label: option.name + ) + |> builder.set_sort_scope(SortScope.global()) + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex new file mode 100644 index 00000000..dd9064b8 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex @@ -0,0 +1,222 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Callable do + alias Lexical.Ast.Env + alias Lexical.RemoteControl.Completion.Candidate + alias Expert.CodeIntelligence.Completion.Builder + alias Expert.CodeIntelligence.Completion.SortScope + + @callables [Candidate.Function, Candidate.Macro, Candidate.Callback, Candidate.Typespec] + + @syntax_macros ~w(= == == === =~ .. ..// ! != !== &&) + + def completion(%_callable_module{name: name} = callable, %Env{} = env) + when name in @syntax_macros do + if String.ends_with?(env.prefix, "Kernel.") do + do_completion(callable, env) + else + :skip + end + end + + def completion(%callable_module{arity: 0} = callable, %Env{} = env) + when callable_module in @callables do + unless Env.in_context?(env, :pipe) do + do_completion(callable, env) + end + end + + def completion(%callable_module{} = callable, %Env{} = env) + when callable_module in @callables do + do_completion(callable, env) + end + + # for a callable to be local, it must be defined in the current scope, + # or be a callback. + defp do_completion(callable, %Env{} = env) do + add_args? = not String.contains?(env.suffix, "(") + + insert_text = + if add_args? do + callable_snippet(callable, env) + else + callable.name + end + + tags = + if Map.get(callable.metadata, :deprecated) do + [:deprecated] + end + + kind = + case callable do + %Candidate.Typespec{} -> + :type_parameter + + _ -> + :function + end + + detail = + if callback?(callable) do + "(callback)" + else + "(#{callable.type})" + end + + env + |> Builder.snippet(insert_text, + label: label(callable, env), + kind: kind, + detail: detail, + sort_text: sort_text(callable), + filter_text: "#{callable.name}", + documentation: build_docs(callable), + tags: tags + ) + |> maybe_boost(callable, env) + end + + def capture_completions(%callable_module{} = callable, %Env{} = env) + when callable_module in @callables do + name_and_arity = name_and_arity(callable) + + complete_capture = + env + |> Builder.plain_text(name_and_arity, + label: name_and_arity, + kind: :function, + detail: "(Capture)", + sort_text: sort_text(callable), + filter_text: "#{callable.name}", + documentation: build_docs(callable) + ) + |> maybe_boost(callable, env) + + call_capture = + env + |> Builder.snippet(callable_snippet(callable, env), + label: label(callable, env), + kind: :function, + detail: "(Capture with arguments)", + sort_text: sort_text(callable), + filter_text: "#{callable.name}", + documentation: build_docs(callable) + ) + |> maybe_boost(callable, env) + + [complete_capture, call_capture] + end + + defp argument_names(%_{arity: 0}, _env) do + [] + end + + defp argument_names(%_{} = callable, %Env{} = env) do + if Env.in_context?(env, :pipe) do + tl(callable.argument_names) + else + callable.argument_names + end + end + + defp callable_snippet(%_{} = callable, env) do + argument_templates = + callable + |> argument_names(env) + |> Enum.with_index(1) + |> Enum.map_join(", ", fn {name, index} -> + "${#{index}:#{name}}" + end) + + if callable.parens? do + "#{callable.name}(#{argument_templates})" + else + "#{callable.name} #{argument_templates}" + end + end + + @default_functions ["module_info", "behaviour_info"] + + defp maybe_boost(item, callable, %Env{} = env) do + position_module = env.position_module + + %_{ + name: name, + origin: origin, + metadata: metadata + } = callable + + # elixir_sense suggests child_spec as a callback, though it's not formally one. + deprecated? = Map.has_key?(metadata, :deprecated) + dunder? = String.starts_with?(name, "__") + callback? = callback?(callable) + + local_priority = + cond do + dunder? -> 9 + callback? -> 8 + true -> 1 + end + + cond do + origin === "Kernel" or origin === "Kernel.SpecialForms" or name in @default_functions -> + local_priority = if dunder?, do: 9, else: 1 + Builder.set_sort_scope(item, SortScope.global(deprecated?, local_priority)) + + origin === position_module -> + Builder.set_sort_scope(item, SortScope.local(deprecated?, local_priority)) + + true -> + Builder.set_sort_scope(item, SortScope.remote(deprecated?, local_priority)) + end + end + + defp label(%_{} = callable, env) do + arg_detail = callable |> argument_names(env) |> Enum.join(", ") + + if callable.parens? do + "#{callable.name}(#{arg_detail})" + else + "#{callable.name} #{arg_detail}" + end + end + + defp name_and_arity(%_{name: name, arity: arity}) do + "#{name}/#{arity}" + end + + defp sort_text(%_callable{name: name, arity: arity}) do + normalized_arity = + arity + |> Integer.to_string() + |> String.pad_leading(3, "0") + + # we used to use : as a separator between the name and + # arity, but this caused bang functions to sort + # before non-bang variants, which is incorrect. + # Using a space sorts correctly, as it's the only ascii + # character lower than bang + + "#{name} #{normalized_arity}" + end + + defp build_docs(%{summary: summary, spec: spec}) + when is_binary(summary) and is_binary(spec) do + "#{summary}\n```elixir\n#{spec}\n```" + end + + defp build_docs(%{summary: summary}) when is_binary(summary) do + summary + end + + defp build_docs(%{spec: spec}) when is_binary(spec) do + "```elixir\n#{spec}\n```" + end + + defp build_docs(_) do + "" + end + + defp callback?(%_{name: name, metadata: metadata} = _callable) do + Map.has_key?(metadata, :implementing) || name === "child_spec" + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex new file mode 100644 index 00000000..3805e902 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex @@ -0,0 +1,103 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Callback do + alias Lexical.Ast.Env + alias Lexical.Document + alias Lexical.RemoteControl.Completion.Candidate.Callback + alias Expert.CodeIntelligence.Completion.Builder + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + + defimpl Translatable, for: Callback do + def translate(callback, _builder, %Env{} = env) do + %Callback{ + name: name, + argument_names: arg_names, + summary: summary + } = callback + + %Env{line: line} = env + + env + |> Builder.text_edit_snippet( + insert_text(name, arg_names, env), + line_range(line), + label: label(name, arg_names), + kind: :interface, + detail: detail(callback), + sort_text: sort_text(callback), + filter_text: "def #{name}", + documentation: summary + ) + |> Builder.set_sort_scope(SortScope.local()) + end + + defp insert_text(name, arg_names, env) + when is_binary(name) and is_list(arg_names) do + impl_line(name, env) <> + "def #{name}(#{arg_text(arg_names)}) do" <> + "\n $0\nend" + end + + # add tab stops and join with ", " + defp arg_text(args) do + args + |> Enum.with_index(fn arg, i -> + "${#{i + 1}:#{arg}}" + end) + |> Enum.join(", ") + end + + # elixir_sense suggests child_spec/1 as a callback as it's a common idiom, + # but not an actual callback of behaviours like GenServer. + defp impl_line("child_spec", _env), do: "" + + # It's generally safe adding `@impl true` to callbacks as Elixir warns + # of conflicting behaviours, and they're virtually non-existent anyway. + defp impl_line(_, %Env{} = env) do + with {:ok, line_before} <- Document.fetch_text_at(env.document, env.position.line - 1), + true <- line_before =~ "@impl" do + "" + else + _ -> "@impl true\n" + end + end + + defp line_range(line) when is_binary(line) do + start_char = + case String.split(line, "def", parts: 2) do + [i, _] -> String.length(i) + 1 + [_] -> 0 + end + + end_char = String.length(line) + 1 + + {start_char, end_char} + end + + defp label(name, arg_names) + when is_binary(name) and is_list(arg_names) do + "#{name}(#{Enum.join(arg_names, ", ")})" + end + + defp detail(%Callback{name: "child_spec"}) do + "supervision specification" + end + + defp detail(%Callback{origin: origin, metadata: %{optional: false}}) do + "#{origin} callback (required)" + end + + defp detail(%Callback{origin: origin}) do + "#{origin} callback" + end + + # cribbed from the Callable translation for now. + defp sort_text(%Callback{name: name, arity: arity}) do + normalized_arity = + arity + |> Integer.to_string() + |> String.pad_leading(3, "0") + + "#{name}:#{normalized_arity}" + end + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex new file mode 100644 index 00000000..7c5ff947 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex @@ -0,0 +1,16 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Function do + alias Lexical.Ast.Env + alias Lexical.RemoteControl.Completion.Candidate + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations + + defimpl Translatable, for: Candidate.Function do + def translate(function, _builder, %Env{} = env) do + if Env.in_context?(env, :function_capture) do + Translations.Callable.capture_completions(function, env) + else + Translations.Callable.completion(function, env) + end + end + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex new file mode 100644 index 00000000..01b35b41 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex @@ -0,0 +1,678 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Macro do + alias Lexical.Ast + alias Lexical.Ast.Env + alias Lexical.Document + alias Lexical.Document.Position + alias Lexical.RemoteControl.Completion.Candidate + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations + alias Expert.CodeIntelligence.Completion.Translations.Callable + alias Expert.CodeIntelligence.Completion.Translations.Struct + + @snippet_macros ~w(def defp defmacro defmacrop defimpl defmodule defprotocol defguard defguardp defexception test use) + @unhelpful_macros ~w(:: alias! in and or destructure) + + defimpl Translatable, for: Candidate.Macro do + def translate(macro, builder, %Env{} = env) do + Translations.Macro.translate(macro, builder, env) + end + end + + def translate(%Candidate.Macro{name: name}, _builder, _env) + when name in ["__before_compile__", "__using__", "__after_compile__"] do + :skip + end + + def translate(%Candidate.Macro{name: "def", arity: 2} = macro, builder, env) do + function_snippet("def", "define a function", macro, builder, env) + end + + def translate(%Candidate.Macro{name: "defp", arity: 2} = macro, builder, env) do + function_snippet("defp", "define a private function", macro, builder, env) + end + + def translate(%Candidate.Macro{name: "defmodule"} = macro, builder, env) do + label = "defmodule (define a module)" + suggestion = suggest_module_name(env.document) + + snippet = """ + defmodule ${1:#{suggestion}} do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defmacro", arity: 2} = macro, builder, env) do + label = "#{macro.name} (define a macro)" + + snippet = """ + defmacro ${1:name}($2) do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defmacrop", arity: 2} = macro, builder, env) do + label = "#{macro.name} (define a private macro)" + + snippet = """ + defmacrop ${1:name}($2) do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defprotocol"} = macro, builder, env) do + label = "#{macro.name} (define a protocol)" + + snippet = """ + defprotocol ${1:protocol_name} do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defimpl", arity: 3} = macro, builder, env) do + label = "#{macro.name} (define a protocol implementation)" + + snippet = """ + defimpl ${1:protocol_name}, for: ${2:struct_name} do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defoverridable"} = macro, builder, env) do + label = "#{macro.name} (mark a function as overridable)" + + snippet = "defoverridable ${1:keyword_or_behaviour}" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defdelegate", arity: 2} = macro, builder, env) do + label = "#{macro.name} (define a delegate function)" + + snippet = "defdelegate ${1:call}(${2:args}), to: ${3:module}" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defguard", arity: 1} = macro, builder, env) do + label = "#{macro.name} (define a guard macro)" + + snippet = "defguard ${1:guard}(${2:args}) when $0" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defguardp", arity: 1} = macro, builder, env) do + label = "#{macro.name} (define a private guard macro)" + + snippet = "defguardp ${1:guard}(${2:args}) when $0" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defexception", arity: 1} = macro, builder, env) do + label = "#{macro.name} (define an exception)" + + snippet = "defexception [${1::message}]" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "defstruct", arity: 1} = macro, builder, env) do + label = "#{macro.name} (define a struct)" + + snippet = "defstruct [${1:fields}]" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "alias", arity: 2} = macro, builder, env) do + label = "#{macro.name} (alias a module's name)" + + snippet = "alias $0" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "use", arity: 1}, builder, env) do + label = "use (invoke another module's __using__ macro)" + snippet = "use $0" + + env + |> builder.snippet(snippet, + kind: :class, + label: label, + filter_text: "use" + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "require" <> _, arity: 2} = macro, builder, env) do + label = "#{macro.name} (require a module's macros)" + + snippet = "require $0" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "quote" <> _, arity: 2} = macro, builder, env) do + label = "#{macro.name} (quote block)" + + snippet = """ + quote $1 do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "receive" <> _, arity: 1} = macro, builder, env) do + label = "#{macro.name} (receive block)" + + snippet = """ + receive do + ${1:pattern} -> $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "try" <> _, arity: 1} = macro, builder, env) do + label = "#{macro.name} (try / catch / rescue block)" + + snippet = """ + try do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "with" <> _, arity: 1} = macro, builder, env) do + label = "#{macro.name} (with statement)" + + snippet = """ + with ${1:pattern} <- ${2:expression} do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "case", arity: 2} = macro, builder, env) do + label = "#{macro.name} (case statement)" + + snippet = """ + case $1 do + ${2:pattern} -> $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "if", arity: 2} = macro, builder, env) do + label = "#{macro.name} (if statement)" + + snippet = """ + if $1 do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "import", arity: 2} = macro, builder, env) do + label = "#{macro.name} (import a module's functions)" + + snippet = "import $0" + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "unless", arity: 2} = macro, builder, env) do + label = "#{macro.name} (unless statement)" + + snippet = """ + unless $1 do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "cond"} = macro, builder, env) do + label = "#{macro.name} (cond statement)" + + snippet = """ + cond do + ${1:test} -> + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "for"} = macro, builder, env) do + label = "#{macro.name} (comprehension)" + + snippet = """ + for ${1:pattern} <- ${2:enumerable} do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + @stub_label ~S(test "message" ) + @plain_label ~S(test "message" do... ) + @context_label ~S(test "message", %{} do...) + + def translate(%Candidate.Macro{name: "test", arity: 1}, builder, env) do + stub_label = @stub_label + + stub_snippet = ~S(test "${0:message}") + + env + |> builder.snippet(stub_snippet, + detail: "A stub test", + kind: :class, + label: stub_label, + filter_text: "test" + ) + |> builder.set_sort_scope(SortScope.remote(false, 2)) + end + + def translate(%Candidate.Macro{name: "test", arity: 2}, builder, env) do + plain_label = @plain_label + + plain_snippet = """ + test "${1:message}" do + $0 + end + """ + + env + |> builder.snippet(plain_snippet, + detail: "A test", + kind: :class, + label: plain_label, + filter_text: "test" + ) + |> builder.set_sort_scope(SortScope.remote(false, 0)) + end + + def translate(%Candidate.Macro{name: "test", arity: 3}, builder, env) do + context_label = @context_label + + context_snippet = """ + test "${1:message}", %{${2:context}} do + $0 + end + """ + + env + |> builder.snippet(context_snippet, + detail: "A test that receives context", + kind: :class, + label: context_label, + filter_text: "test" + ) + |> builder.set_sort_scope(SortScope.remote(false, 1)) + end + + def translate(%Candidate.Macro{name: "describe"}, builder, env) do + snippet = """ + describe "${1:message}" do + $0 + end + """ + + env + |> builder.snippet(snippet, + detail: "A describe block", + kind: :class, + label: ~S(describe "message"), + filter_text: "describe" + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: "__MODULE__"} = macro, builder, env) do + if Env.in_context?(env, :struct_reference) do + Struct.completion(env, builder, macro.name, macro.name) + else + env + |> builder.plain_text("__MODULE__", + detail: macro.spec, + kind: :constant, + label: "__MODULE__", + filter_text: "__MODULE__" + ) + |> builder.set_sort_scope(SortScope.global()) + end + end + + def translate(%Candidate.Macro{name: dunder_form} = macro, builder, env) + when dunder_form in ~w(__CALLER__ __DIR__ __ENV__ __MODULE__ __STACKTRACE__) do + env + |> builder.plain_text(dunder_form, + detail: macro.spec, + kind: :constant, + label: dunder_form, + filter_text: dunder_form + ) + |> builder.set_sort_scope(SortScope.global()) + end + + def translate(%Candidate.Macro{name: dunder_form}, _builder, _env) + when dunder_form in ~w(__aliases__ __block__) do + :skip + end + + def translate(%Candidate.Macro{name: name}, _builder, _env) + when name in @unhelpful_macros do + :skip + end + + def translate(%Candidate.Macro{name: name} = macro, _builder, env) + when name not in @snippet_macros do + Callable.completion(macro, env) + end + + def translate(%Candidate.Macro{}, _builder, _env) do + :skip + end + + defp function_snippet(kind, label, %Candidate.Macro{} = macro, builder, env) do + label = "#{macro.name} (#{label})" + + snippet = + with {:ok, %Position{} = position} <- Env.prev_significant_position(env), + {:ok, name, args} <- extract_spec_name_and_args(env, position) do + args_snippet = + case suggest_arg_names(args) do + [] -> + "" + + names -> + placeholders = + names + |> Enum.with_index(1) + |> Enum.map_join(", ", fn {name, i} -> "${#{i}:#{name}}" end) + + "(" <> placeholders <> ")" + end + + """ + #{kind} #{name}#{args_snippet} do + $0 + end + """ + else + _ -> + """ + #{kind} ${1:name}($2) do + $0 + end + """ + end + + env + |> builder.snippet(snippet, + detail: macro.spec, + kind: :class, + label: label, + filter_text: macro.name + ) + |> builder.set_sort_scope(SortScope.global()) + end + + defp extract_spec_name_and_args(%Env{} = env, %Position{} = position) do + with {:ok, [maybe_spec | _]} <- Ast.path_at(env.analysis, position), + {:@, _, [{:spec, _, [typespec]}]} <- maybe_spec, + {:"::", _, [{name, _, args}, _return]} <- typespec do + if is_list(args) do + {:ok, name, args} + else + {:ok, name, []} + end + else + _ -> :error + end + end + + defp suggest_arg_names(args) do + Enum.with_index(args, fn + {:"::", _, [{name, _, nil}, _]}, _i when is_atom(name) -> name + _, i -> "arg_#{i + 1}" + end) + end + + defp suggest_module_name(%Document{} = document) do + result = + document.path + |> Path.split() + |> Enum.reduce(false, fn + "lib", _ -> + {:lib, []} + + "test", _ -> + {:test, []} + + "support", {:test, _} -> + {:lib, []} + + _, false -> + false + + element, {type, elements} -> + camelized = camelize_file_name(element) + + {type, [camelized | elements]} + end) + + case result do + {_, parts} -> + parts + |> Enum.reverse() + |> Enum.join(".") + + false -> + document.path + |> Path.basename() + |> camelize_file_name() + end + end + + defp camelize_file_name(file_name_with_extension) do + file_name_with_extension + |> Path.rootname() + |> String.split(".") + |> Enum.map_join(".", &Macro.camelize/1) + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex new file mode 100644 index 00000000..8117ec89 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex @@ -0,0 +1,27 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.MapField do + alias Lexical.Ast.Env + alias Lexical.RemoteControl.Completion.Candidate + alias Expert.CodeIntelligence.Completion.Translatable + + defimpl Translatable, for: Candidate.MapField do + def translate(%Candidate.MapField{} = map_field, builder, %Env{} = env) do + builder.text_edit(env, map_field.name, range(env), + detail: map_field.name, + label: map_field.name, + kind: :field + ) + end + + defp range(%Env{} = env) do + case Env.prefix_tokens(env, 1) do + # ensure the text edit doesn't overwrite the dot operator + # when we're completing immediately after it: some_map.| + [{:operator, :., {_line, char}}] -> + {char + 1, env.position.character} + + [{_, _, {_line, char}}] -> + {char, env.position.character} + end + end + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex new file mode 100644 index 00000000..2845dc07 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex @@ -0,0 +1,178 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.ModuleAttribute do + alias Lexical.Ast + alias Lexical.Ast.Env + alias Lexical.Document.Position + alias Lexical.RemoteControl.Completion.Candidate + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations + + defimpl Translatable, for: Candidate.ModuleAttribute do + def translate(attribute, builder, %Env{} = env) do + Translations.ModuleAttribute.translate(attribute, builder, env) + end + end + + def translate(%Candidate.ModuleAttribute{name: "@moduledoc"}, builder, env) do + doc_snippet = ~s''' + @moduledoc """ + $0 + """ + ''' + + case fetch_range(env) do + {:ok, range} -> + with_doc = + builder.text_edit_snippet(env, doc_snippet, range, + detail: "Document public module", + kind: :property, + label: "@moduledoc" + ) + + without_doc = + builder.text_edit(env, "@moduledoc false", range, + detail: "Mark as private", + kind: :property, + label: "@moduledoc false" + ) + + [with_doc, without_doc] + + :error -> + :skip + end + end + + def translate(%Candidate.ModuleAttribute{name: "@doc"}, builder, env) do + doc_snippet = ~s''' + @doc """ + $0 + """ + ''' + + case fetch_range(env) do + {:ok, range} -> + with_doc = + builder.text_edit_snippet(env, doc_snippet, range, + detail: "Document public function", + kind: :property, + label: "@doc" + ) + + without_doc = + builder.text_edit(env, "@doc false", range, + detail: "Mark as private", + kind: :property, + label: "@doc false" + ) + + [with_doc, without_doc] + + :error -> + :skip + end + end + + def translate(%Candidate.ModuleAttribute{name: "@spec"}, builder, env) do + case fetch_range(env) do + {:ok, range} -> + [ + maybe_specialized_spec_snippet(builder, env, range), + basic_spec_snippet(builder, env, range) + ] + + :error -> + :skip + end + end + + def translate(%Candidate.ModuleAttribute{} = attribute, builder, env) do + case fetch_range(env) do + {:ok, range} -> + builder.text_edit(env, attribute.name, range, + detail: "module attribute", + kind: :constant, + label: attribute.name + ) + + :error -> + :skip + end + end + + defp fetch_range(%Env{} = env) do + case fetch_at_op_on_same_line(env) do + {:ok, {:at_op, _, {_line, char}}} -> + {:ok, {char, env.position.character}} + + _ -> + :error + end + end + + defp fetch_at_op_on_same_line(%Env{} = env) do + Enum.reduce_while(Env.prefix_tokens(env), :error, fn + {:at_op, _, _} = at_op, _acc -> + {:halt, {:ok, at_op}} + + {:eol, _, _}, _acc -> + {:halt, :error} + + _, acc -> + {:cont, acc} + end) + end + + defp maybe_specialized_spec_snippet(builder, %Env{} = env, range) do + with {:ok, %Position{} = position} <- Env.next_significant_position(env), + {:ok, [{maybe_def, _, [call, _]} | _]} when maybe_def in [:def, :defp] <- + Ast.path_at(env.analysis, position), + {function_name, _, args} <- call do + specialized_spec_snippet(builder, env, range, function_name, args) + else + _ -> nil + end + end + + defp specialized_spec_snippet(builder, env, range, function_name, args) do + name = to_string(function_name) + + args_snippet = + case args do + nil -> + "" + + list -> + Enum.map_join(1..length(list), ", ", &"${#{&1}:term()}") + end + + snippet = ~s""" + @spec #{name}(#{args_snippet}) :: ${0:term()} + """ + + env + |> builder.text_edit_snippet(snippet, range, + detail: "Typespec", + kind: :property, + label: "@spec #{name}" + ) + |> builder.set_sort_scope(SortScope.global(false, 0)) + end + + defp basic_spec_snippet(builder, env, range) do + snippet = ~S""" + @spec ${1:function}(${2:term()}) :: ${3:term()} + def ${1:function}(${4:args}) do + $0 + end + """ + + env + |> builder.text_edit_snippet(snippet, range, + detail: "Typespec", + kind: :property, + label: "@spec" + ) + |> builder.set_sort_scope(SortScope.global(false, 1)) + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex new file mode 100644 index 00000000..bc29fd2a --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex @@ -0,0 +1,145 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.ModuleOrBehaviour do + alias Lexical.Ast.Env + alias Lexical.RemoteControl.Completion.Candidate + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations + alias Expert.Project.Intelligence + + defimpl Translatable, for: Candidate.Module do + def translate(module, builder, %Env{} = env) do + Translations.ModuleOrBehaviour.translate(module, builder, env) + end + end + + defimpl Translatable, for: Candidate.Struct do + def translate(module, builder, %Env{} = env) do + Translations.ModuleOrBehaviour.translate(module, builder, env) + end + end + + defimpl Translatable, for: Candidate.Behaviour do + def translate(behaviour, builder, %Env{} = env) do + Translations.ModuleOrBehaviour.translate(behaviour, builder, env) + end + end + + defimpl Translatable, for: Candidate.Protocol do + def translate(protocol, builder, %Env{} = env) do + Translations.ModuleOrBehaviour.translate(protocol, builder, env) + end + end + + def translate(%_{} = module, builder, %Env{} = env) do + if Env.in_context?(env, :struct_reference) do + complete_in_struct_reference(env, builder, module) + else + detail = builder.fallback(module.summary, module.full_name) + completion(env, builder, module.name, detail) + end + end + + defp complete_in_struct_reference(%Env{} = env, builder, %Candidate.Struct{} = struct) do + immediate_descendent_structs = + immediate_descendent_struct_modules(env.project, struct.full_name) + + if Enum.empty?(immediate_descendent_structs) do + Translations.Struct.completion(env, builder, struct.name, struct.full_name) + else + do_complete_in_struct_reference(env, builder, struct, immediate_descendent_structs) + end + end + + defp complete_in_struct_reference(%Env{} = env, builder, %Candidate.Module{} = module) do + immediate_descendent_structs = + immediate_descendent_struct_modules(env.project, module.full_name) + + do_complete_in_struct_reference(env, builder, module, immediate_descendent_structs) + end + + defp do_complete_in_struct_reference( + %Env{} = env, + builder, + module_or_struct, + immediate_descendent_structs + ) do + structs_mapset = MapSet.new(immediate_descendent_structs) + dot_counts = module_dot_counts(module_or_struct.full_name) + ancestors = ancestors(immediate_descendent_structs, dot_counts) + + Enum.flat_map(ancestors, fn ancestor -> + local_name = local_module_name(module_or_struct.full_name, ancestor, module_or_struct.name) + + more = + env.project + |> Intelligence.collect_struct_modules(ancestor, to: :infinity) + |> Enum.count() + + if struct?(ancestor, structs_mapset) do + [ + Translations.Struct.completion(env, builder, local_name, ancestor), + Translations.Struct.completion(env, builder, local_name, ancestor, more - 1) + ] + else + [Translations.Struct.completion(env, builder, local_name, ancestor, more)] + end + end) + end + + defp struct?(module, structs_mapset) do + MapSet.member?(structs_mapset, module) + end + + defp ancestors(results, dot_counts) do + results + |> Enum.map(fn module -> + module |> String.split(".") |> Enum.take(dot_counts + 1) |> Enum.join(".") + end) + |> Enum.uniq() + end + + # this skips grapheme translations + defp module_dot_counts(module_name), do: module_dot_counts(module_name, 0) + + defp module_dot_counts(<<>>, count), do: count + defp module_dot_counts(<<".", rest::binary>>, count), do: module_dot_counts(rest, count + 1) + defp module_dot_counts(<<_::utf8, rest::binary>>, count), do: module_dot_counts(rest, count) + + def completion(%Env{} = env, builder, module_name, detail \\ nil) do + detail = builder.fallback(detail, "#{module_name} (Module)") + + env + |> builder.plain_text(module_name, label: module_name, kind: :module, detail: detail) + |> builder.set_sort_scope(SortScope.module()) + end + + defp local_module_name(parent_module, child_module, aliased_module) do + # Returns the "local" module name, so if you're completing + # Types.Som and the module completion is "Types.Something.Else", + # "Something.Else" is returned. + + parent_pieces = String.split(parent_module, ".") + parent_pieces = Enum.take(parent_pieces, length(parent_pieces) - 1) + local_module_name = Enum.join(parent_pieces, ".") + local_module_length = String.length(local_module_name) + + local_name = + child_module + |> String.slice(local_module_length..-1//1) + |> strip_leading_period() + + if String.starts_with?(local_name, aliased_module) do + local_name + else + [_ | tail] = String.split(local_name, ".") + Enum.join([aliased_module | tail], ".") + end + end + + defp strip_leading_period(<<".", rest::binary>>), do: rest + defp strip_leading_period(string_without_period), do: string_without_period + + defp immediate_descendent_struct_modules(%Lexical.Project{} = project, module_name) do + Intelligence.collect_struct_modules(project, module_name, to: :grandchild) + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/struct.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/struct.ex new file mode 100644 index 00000000..d6049bbb --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/struct.ex @@ -0,0 +1,93 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Struct do + alias Future.Code, as: Code + alias Lexical.Ast.Env + alias Lexical.Formats + + def completion(%Env{} = _env, _builder, _module_name, _full_name, 0) do + nil + end + + def completion(%Env{} = env, builder, module_name, full_name, more) when is_integer(more) do + singular = "${count} more struct" + plural = "${count} more structs" + + builder_opts = [ + kind: :module, + label: "#{module_name}...(#{Formats.plural(more, singular, plural)})", + detail: "#{full_name}." + ] + + insert_text = "#{module_name}." + range = edit_range(env) + + builder.text_edit_snippet(env, insert_text, range, builder_opts) + end + + def completion(%Env{} = env, builder, struct_name, full_name) do + builder_opts = [ + kind: :struct, + detail: "#{full_name}", + label: "#{struct_name}" + ] + + range = edit_range(env) + + insert_text = + if add_curlies?(env) do + struct_name <> "{$1}" + else + struct_name + end + + builder.text_edit_snippet(env, insert_text, range, builder_opts) + end + + defp add_curlies?(%Env{} = env) do + if Env.in_context?(env, :struct_reference) do + not String.contains?(env.suffix, "{") + else + false + end + end + + defp edit_range(%Env{} = env) do + prefix_end = env.position.character + + edit_begin = + case Code.Fragment.cursor_context(env.prefix) do + {:struct, {:dot, {:alias, _typed_module}, _rest}} -> + prefix_end + + {:struct, typed_module_name} -> + beginning_of_edit(env, typed_module_name) + + {:local_or_var, [?_ | _rest] = typed} -> + beginning_of_edit(env, typed) + end + + {edit_begin, env.position.character} + end + + defp beginning_of_edit(env, typed_module_name) do + case left_offset_of(typed_module_name, ?.) do + {:ok, offset} -> + env.position.character - offset + + :error -> + env.position.character - length(typed_module_name) + end + end + + defp left_offset_of(string, character) do + string + |> Enum.reverse() + |> Enum.with_index() + |> Enum.reduce_while(:error, fn + {^character, index}, _ -> + {:halt, {:ok, index}} + + _, acc -> + {:cont, acc} + end) + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex new file mode 100644 index 00000000..0521051e --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex @@ -0,0 +1,57 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.StructField do + alias Future.Code, as: Code + alias Lexical.Ast.Env + alias Lexical.RemoteControl.Completion.Candidate + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations + + defimpl Translatable, for: Candidate.StructField do + def translate(field, builder, %Env{} = env) do + Translations.StructField.translate(field, builder, env) + end + end + + def translate(%Candidate.StructField{name: "__struct__"}, _builder, _env) do + :skip + end + + def translate(%Candidate.StructField{call?: false} = struct_field, builder, %Env{} = env) do + name = struct_field.name + value = to_string(name) + + builder_opts = [ + kind: :field, + label: "#{name}: #{value}", + filter_text: "#{name}:" + ] + + insert_text = "#{name}: ${1:#{value}}" + range = edit_range(env) + + env + |> builder.text_edit_snippet(insert_text, range, builder_opts) + |> builder.set_sort_scope(SortScope.variable()) + end + + def translate(%Candidate.StructField{} = struct_field, builder, %Env{} = env) do + builder.plain_text(env, struct_field.name, + detail: struct_field.type_spec, + label: struct_field.name, + kind: :field + ) + end + + def edit_range(env) do + prefix_end = env.position.character + + case Code.Fragment.cursor_context(env.prefix) do + {:local_or_var, field_char} -> + edit_begin = env.position.character - length(field_char) + {edit_begin, prefix_end} + + _ -> + {prefix_end, prefix_end} + end + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex new file mode 100644 index 00000000..fd6bdf58 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex @@ -0,0 +1,12 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Typespec do + alias Lexical.Ast.Env + alias Lexical.RemoteControl.Completion.Candidate + alias Expert.CodeIntelligence.Completion.Translatable + alias Expert.CodeIntelligence.Completion.Translations.Callable + + defimpl Translatable, for: Candidate.Typespec do + def translate(typespec, _builder, %Env{} = env) do + Callable.completion(typespec, env) + end + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex new file mode 100644 index 00000000..19d1b438 --- /dev/null +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex @@ -0,0 +1,18 @@ +defmodule Expert.CodeIntelligence.Completion.Translations.Variable do + alias Lexical.Ast.Env + alias Lexical.RemoteControl.Completion.Candidate + alias Expert.CodeIntelligence.Completion.SortScope + alias Expert.CodeIntelligence.Completion.Translatable + + defimpl Translatable, for: Candidate.Variable do + def translate(variable, builder, %Env{} = env) do + env + |> builder.plain_text(variable.name, + detail: variable.name, + kind: :variable, + label: variable.name + ) + |> builder.set_sort_scope(SortScope.variable()) + end + end +end diff --git a/expert/lib/lexical/server/configuration.ex b/expert/lib/lexical/server/configuration.ex new file mode 100644 index 00000000..c568e247 --- /dev/null +++ b/expert/lib/lexical/server/configuration.ex @@ -0,0 +1,142 @@ +defmodule Expert.Configuration do + @moduledoc """ + Encapsulates server configuration options and client capability support. + """ + + alias Lexical.Project + alias Lexical.Protocol.Id + alias Lexical.Protocol.Notifications.DidChangeConfiguration + alias Lexical.Protocol.Requests + alias Lexical.Protocol.Requests.RegisterCapability + alias Lexical.Protocol.Types.ClientCapabilities + alias Lexical.Protocol.Types.Registration + alias Expert.Configuration.Support + alias Expert.Dialyzer + + defstruct project: nil, + support: nil, + client_name: nil, + additional_watched_extensions: nil, + dialyzer_enabled?: false + + @type t :: %__MODULE__{ + project: Project.t() | nil, + support: support | nil, + client_name: String.t() | nil, + additional_watched_extensions: [String.t()] | nil, + dialyzer_enabled?: boolean() + } + + @opaque support :: Support.t() + + @dialyzer {:nowarn_function, set_dialyzer_enabled: 2} + + @spec new(Lexical.uri(), map(), String.t() | nil) :: t + def new(root_uri, %ClientCapabilities{} = client_capabilities, client_name) do + support = Support.new(client_capabilities) + project = Project.new(root_uri) + + %__MODULE__{support: support, project: project, client_name: client_name} + |> tap(&set/1) + end + + @spec new(keyword()) :: t + def new(attrs \\ []) do + struct!(__MODULE__, [support: Support.new()] ++ attrs) + end + + defp set(%__MODULE__{} = config) do + :persistent_term.put(__MODULE__, config) + end + + @spec get() :: t + def get do + :persistent_term.get(__MODULE__, false) || new() + end + + @spec client_supports?(atom()) :: boolean() + def client_supports?(key) when is_atom(key) do + client_supports?(get().support, key) + end + + defp client_supports?(%Support{} = client_support, key) do + case Map.fetch(client_support, key) do + {:ok, value} -> value + :error -> raise ArgumentError, "unknown key: #{inspect(key)}" + end + end + + @spec default(t | nil) :: + {:ok, t} + | {:ok, t, Requests.RegisterCapability.t()} + def default(nil) do + {:ok, default_config()} + end + + def default(%__MODULE__{} = config) do + apply_config_change(config, default_config()) + end + + @spec on_change(t, DidChangeConfiguration.t()) :: + {:ok, t} + | {:ok, t, Requests.RegisterCapability.t()} + def on_change(%__MODULE__{} = old_config, :defaults) do + apply_config_change(old_config, default_config()) + end + + def on_change(%__MODULE__{} = old_config, %DidChangeConfiguration{} = change) do + apply_config_change(old_config, change.lsp.settings) + end + + defp default_config do + %{} + end + + defp apply_config_change(%__MODULE__{} = old_config, %{} = settings) do + old_config + |> set_dialyzer_enabled(settings) + |> maybe_add_watched_extensions(settings) + end + + defp set_dialyzer_enabled(%__MODULE__{} = old_config, settings) do + enabled? = + if Dialyzer.check_support() == :ok do + Map.get(settings, "dialyzerEnabled", true) + else + false + end + + %__MODULE__{old_config | dialyzer_enabled?: enabled?} + end + + defp maybe_add_watched_extensions(%__MODULE__{} = old_config, %{ + "additionalWatchedExtensions" => [] + }) do + {:ok, old_config} + end + + defp maybe_add_watched_extensions(%__MODULE__{} = old_config, %{ + "additionalWatchedExtensions" => extensions + }) + when is_list(extensions) do + register_id = Id.next() + request_id = Id.next() + + watchers = Enum.map(extensions, fn ext -> %{"globPattern" => "**/*#{ext}"} end) + + registration = + Registration.new( + id: request_id, + method: "workspace/didChangeWatchedFiles", + register_options: %{"watchers" => watchers} + ) + + request = RegisterCapability.new(id: register_id, registrations: [registration]) + + {:ok, old_config, request} + end + + defp maybe_add_watched_extensions(%__MODULE__{} = old_config, _) do + {:ok, old_config} + end +end diff --git a/expert/lib/lexical/server/configuration/support.ex b/expert/lib/lexical/server/configuration/support.ex new file mode 100644 index 00000000..24f83dd3 --- /dev/null +++ b/expert/lib/lexical/server/configuration/support.ex @@ -0,0 +1,71 @@ +defmodule Expert.Configuration.Support do + @moduledoc false + + alias Lexical.Protocol.Types.ClientCapabilities + + # To track a new client capability, add a new field and the path to the + # capability in the `Lexical.Protocol.Types.ClientCapabilities` struct + # to this mapping: + @client_capability_mapping [ + code_action_dynamic_registration: [ + :text_document, + :code_action, + :dynamic_registration + ], + hierarchical_symbols: [ + :text_document, + :document_symbol, + :hierarchical_document_symbol_support + ], + snippet: [ + :text_document, + :completion, + :completion_item, + :snippet_support + ], + deprecated: [ + :text_document, + :completion, + :completion_item, + :deprecated_support + ], + tags: [ + :text_document, + :completion, + :completion_item, + :tag_support + ], + signature_help: [ + :text_document, + :signature_help + ], + work_done_progress: [ + :window, + :work_done_progress + ] + ] + + defstruct code_action_dynamic_registration: false, + hierarchical_symbols: false, + snippet: false, + deprecated: false, + tags: false, + signature_help: false, + work_done_progress: false + + @type t :: %__MODULE__{} + + def new(%ClientCapabilities{} = client_capabilities) do + defaults = + for {key, path} <- @client_capability_mapping do + value = get_in(client_capabilities, path) || false + {key, value} + end + + struct(__MODULE__, defaults) + end + + def new do + %__MODULE__{} + end +end diff --git a/expert/lib/lexical/server/dialyzer.ex b/expert/lib/lexical/server/dialyzer.ex new file mode 100644 index 00000000..fa7d575b --- /dev/null +++ b/expert/lib/lexical/server/dialyzer.ex @@ -0,0 +1,5 @@ +defmodule Expert.Dialyzer do + def check_support do + :ok + end +end diff --git a/expert/lib/lexical/server/iex/helpers.ex b/expert/lib/lexical/server/iex/helpers.ex new file mode 100644 index 00000000..01fe32aa --- /dev/null +++ b/expert/lib/lexical/server/iex/helpers.ex @@ -0,0 +1,267 @@ +defmodule Expert.IEx.Helpers do + alias Lexical.Ast + alias Lexical.Document + alias Lexical.Document.Position + alias Lexical.Project + alias Lexical.Protocol.Types.Completion + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Search + alias Expert.CodeIntelligence + + defmacro __using__(_) do + quote do + alias Lexical.Document + alias Lexical.Document.Position + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Search + import unquote(__MODULE__) + + RemoteControl.Module.Loader.start_link(nil) + RemoteControl.Dispatch.start_link([]) + end + end + + def observer do + # credo:disable-for-next-line + apply(:observer, :start, []) + end + + def observer(project) do + project + |> ensure_project() + |> RemoteControl.call(:observer, :start) + end + + def doc(text) do + doc(:lexical, text) + end + + def project_node(name) do + name + |> project() + |> Project.node_name() + end + + def doc(project, text) do + root_path = + project + |> project() + |> Project.root_path() + + [root_path, "lib", "file.ex"] + |> Path.join() + |> Document.Path.to_uri() + |> Document.new(text, 0) + end + + def search_store(project) do + project = ensure_project(project) + RemoteControl.set_project(project) + + Search.Store.start_link( + project, + &Search.Indexer.create_index/1, + &Search.Indexer.update_index/2, + Search.Store.Backends.Ets + ) + end + + def search_entries(project) do + {:ok, entries} = + project + |> ensure_project() + |> Search.Indexer.create_index() + + entries + end + + def pos(doc, line, character) do + Position.new(doc, line, character) + end + + def compile_project(project) do + project + |> ensure_project() + |> RemoteControl.Api.schedule_compile(true) + end + + def compile_file(project, source) when is_binary(source) do + project + |> ensure_project() + |> compile_file(doc(source)) + end + + def compile_file(project, %Document{} = document) do + project + |> ensure_project() + |> RemoteControl.Api.compile_document(document) + end + + def complete(project, source, context \\ nil) + + def complete(project, source, context) when is_binary(source) do + case completion_position(source) do + {:found, line, character} -> + analysis = source |> doc() |> Ast.analyze() + complete(project, analysis, line, character, context) + + other -> + other + end + end + + def complete(project, %Ast.Analysis{} = analysis, line, character, context) do + context = + if is_nil(context) do + Completion.Context.new(trigger_kind: :trigger_character) + else + context + end + + position = pos(analysis.document, line, character) + + project + |> ensure_project() + |> CodeIntelligence.Completion.complete(analysis, position, context) + end + + def connect do + manager_name = manager_name() + Node.start(:"r@127.0.0.1") + Node.set_cookie(:lexical) + Node.connect(:"#{manager_name}@127.0.0.1") + end + + @doc """ + Create a Lexical Project for an application in the same directory as + Lexical. + + Alternatively, a project for one of our test fixtures can be created + using the `fixture: true` option. + + ## Examples + + iex> project() + %Lexical.Project{ + root_uri: "file:///.../lexical + ... + } + + iex> project(:my_project) + %Lexical.Project{ + root_uri: "file:///.../my_project" + ... + } + + iex> project(:navigations, fixture: true) + %Lexical.Project{ + root_uri: "file:///.../lexical/apps/remote_control/test/fixtures/navigations" + ... + } + + """ + def project(project \\ :lexical, opts \\ []) do + project = + if opts[:fixture] do + "lexical/apps/remote_control/test/fixtures/#{project}" + else + project + end + + # We're using a cache here because we need project's + # entropy to be the same after every call. + trans(project, fn -> + project_path = + [File.cwd!(), "..", to_string(project)] + |> Path.join() + |> Path.expand() + + project_uri = "file://#{project_path}" + Lexical.Project.new(project_uri) + end) + end + + def current_project do + [prefix, _] = Node.self() |> to_string() |> String.split("@") + [_, project_name, entropy] = String.split(prefix, "-") + %{ensure_project(project_name) | entropy: entropy} + end + + def stop_project(project) do + project + |> ensure_project() + |> Expert.Project.Supervisor.stop() + end + + def start_project(project) do + project + |> ensure_project() + |> Expert.Project.Supervisor.start() + end + + def time(fun) when is_function(fun, 0) do + {elapsed_us, result} = :timer.tc(fun) + + IO.puts([ + IO.ANSI.format([:cyan, :bright, "Time: "]), + Lexical.Formats.time(elapsed_us) + ]) + + result + end + + defp manager_name do + {:ok, names} = :erl_epmd.names() + + names + |> Enum.map(fn {name, _port} -> List.to_string(name) end) + |> Enum.find(&String.starts_with?(&1, "manager")) + end + + defp completion_position(source_string) do + source_string + |> String.split(["\r\n", "\r", "\n"]) + |> Enum.with_index() + |> Enum.reduce_while(:not_found, fn {line, line_number}, _ -> + if String.contains?(line, "|") do + index = + line + |> String.graphemes() + |> Enum.find_index(&(&1 == "|")) + + {:halt, {:found, line_number + 1, index + 1}} + else + {:cont, :not_found} + end + end) + end + + defp ensure_project(%Project{} = project) do + project + end + + defp ensure_project(project) when is_binary(project) do + project + |> String.to_atom() + |> project() + end + + defp ensure_project(project) when is_atom(project) do + project(project) + end + + defp trans(name, function) do + name = {__MODULE__, name} + + case :persistent_term.get(name, :undefined) do + :undefined -> + value = function.() + :persistent_term.put(name, value) + + _ -> + :ok + end + + :persistent_term.get(name) + end +end diff --git a/expert/lib/lexical/server/project/diagnostics.ex b/expert/lib/lexical/server/project/diagnostics.ex new file mode 100644 index 00000000..b2261f53 --- /dev/null +++ b/expert/lib/lexical/server/project/diagnostics.ex @@ -0,0 +1,107 @@ +defmodule Expert.Project.Diagnostics do + alias Lexical.Formats + alias Lexical.Project + alias Lexical.Protocol.Notifications.PublishDiagnostics + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Api.Messages + alias Expert.Project.Diagnostics.State + alias Expert.Transport + + import Messages + require Logger + use GenServer + + def start_link(%Project{} = project) do + GenServer.start_link(__MODULE__, [project], name: name(project)) + end + + def child_spec(%Project{} = project) do + %{ + id: {__MODULE__, Project.name(project)}, + start: {__MODULE__, :start_link, [project]} + } + end + + # GenServer callbacks + + @impl GenServer + def init([%Project{} = project]) do + RemoteControl.Api.register_listener(project, self(), [ + file_diagnostics(), + project_compile_requested(), + project_compiled(), + project_diagnostics() + ]) + + state = State.new(project) + {:ok, state} + end + + @impl GenServer + def handle_info(project_compile_requested(), %State{} = state) do + state = State.clear_all_flushed(state) + {:noreply, state} + end + + @impl GenServer + def handle_info( + project_diagnostics(build_number: build_number, diagnostics: diagnostics), + %State{} = state + ) do + state = + Enum.reduce(diagnostics, state, fn diagnostic, state -> + State.add(state, build_number, diagnostic) + end) + + publish_diagnostics(state) + + {:noreply, state} + end + + @impl GenServer + def handle_info( + file_diagnostics(uri: uri, build_number: build_number, diagnostics: diagnostics), + %State{} = state + ) do + state = + case diagnostics do + [] -> + State.clear(state, uri) + + diagnostics -> + Enum.reduce(diagnostics, state, fn diagnostic, state -> + State.add(state, build_number, diagnostic) + end) + end + + publish_diagnostics(state) + + {:noreply, state} + end + + @impl GenServer + def handle_info( + project_compiled(elapsed_ms: elapsed_ms), + %State{} = state + ) do + project_name = Project.name(state.project) + Logger.info("Compiled #{project_name} in #{Formats.time(elapsed_ms, unit: :millisecond)}") + + {:noreply, state} + end + + # Private + + defp publish_diagnostics(%State{} = state) do + Enum.each(state.entries_by_uri, fn {uri, %State.Entry{} = entry} -> + diagnostics_list = State.Entry.diagnostics(entry) + notification = PublishDiagnostics.new(uri: uri, diagnostics: diagnostics_list) + + Transport.write(notification) + end) + end + + defp name(%Project{} = project) do + :"#{Project.name(project)}::diagnostics" + end +end diff --git a/expert/lib/lexical/server/project/diagnostics/state.ex b/expert/lib/lexical/server/project/diagnostics/state.ex new file mode 100644 index 00000000..8028412a --- /dev/null +++ b/expert/lib/lexical/server/project/diagnostics/state.ex @@ -0,0 +1,103 @@ +defmodule Expert.Project.Diagnostics.State do + defmodule Entry do + defstruct build_number: 0, diagnostics: [] + + def new(build_number) when is_integer(build_number) do + %__MODULE__{build_number: build_number} + end + + def new(build_number, diagnostic) do + %__MODULE__{build_number: build_number, diagnostics: MapSet.new([diagnostic])} + end + + def add(%__MODULE__{} = entry, build_number, diagnostic) do + cond do + build_number < entry.build_number -> + entry + + build_number > entry.build_number -> + new(build_number, diagnostic) + + true -> + %__MODULE__{entry | diagnostics: MapSet.put(entry.diagnostics, diagnostic)} + end + end + + def diagnostics(%__MODULE__{} = entry) do + Enum.to_list(entry.diagnostics) + end + end + + alias Lexical.Document + alias Lexical.Plugin.V1.Diagnostic + alias Lexical.Project + + defstruct project: nil, entries_by_uri: %{} + + require Logger + + def new(%Project{} = project) do + %__MODULE__{project: project} + end + + def get(%__MODULE__{} = state, source_uri) do + entry = Map.get(state.entries_by_uri, source_uri, Entry.new(0)) + Entry.diagnostics(entry) + end + + def clear(%__MODULE__{} = state, source_uri) do + new_entries = Map.put(state.entries_by_uri, source_uri, Entry.new(0)) + + %__MODULE__{state | entries_by_uri: new_entries} + end + + @doc """ + Only clear diagnostics if they've been synced to disk + It's possible that the diagnostic presented by typing is still correct, and the file + that exists on the disk is actually an older copy of the file in memory. + """ + def clear_all_flushed(%__MODULE__{} = state) do + cleared = + Map.new(state.entries_by_uri, fn {uri, %Entry{} = entry} -> + with true <- Document.Store.open?(uri), + {:ok, %Document{} = document} <- Document.Store.fetch(uri), + true <- keep_diagnostics?(document) do + {uri, entry} + else + _ -> + {uri, Entry.new(0)} + end + end) + + %__MODULE__{state | entries_by_uri: cleared} + end + + def add(%__MODULE__{} = state, build_number, %Diagnostic.Result{} = diagnostic) do + entries_by_uri = + Map.update( + state.entries_by_uri, + diagnostic.uri, + Entry.new(build_number, diagnostic), + fn entry -> + Entry.add(entry, build_number, diagnostic) + end + ) + + %__MODULE__{state | entries_by_uri: entries_by_uri} + end + + def add(%__MODULE__{} = state, _build_number, other) do + Logger.error("Invalid diagnostic: #{inspect(other)}") + state + end + + defp keep_diagnostics?(%Document{} = document) do + # Keep any diagnostics for script files, which aren't compiled) + # or dirty files, which have been modified after compilation has occurrend + document.dirty? or script_file?(document) + end + + defp script_file?(document) do + Path.extname(document.path) == ".exs" + end +end diff --git a/expert/lib/lexical/server/project/intelligence.ex b/expert/lib/lexical/server/project/intelligence.ex new file mode 100644 index 00000000..750bd4c6 --- /dev/null +++ b/expert/lib/lexical/server/project/intelligence.ex @@ -0,0 +1,245 @@ +defmodule Expert.Project.Intelligence do + defmodule State do + alias Lexical.Formats + alias Lexical.Project + + defstruct project: nil, struct_modules: MapSet.new() + + def new(%Project{} = project) do + %__MODULE__{project: project} + end + + def delete_struct_module(%__MODULE__{} = state, module_name) do + module_path = module_path(module_name) + + struct_modules = MapSet.delete(state.struct_modules, module_path) + %__MODULE__{state | struct_modules: struct_modules} + end + + def add_struct_module(%__MODULE__{} = state, module_name) do + module_path = module_path(module_name) + %__MODULE__{state | struct_modules: MapSet.put(state.struct_modules, module_path)} + end + + def descendent_defines_struct?(%__MODULE__{} = state, prefix, %Range{} = range) do + module_path = module_path(prefix) + Enum.any?(state.struct_modules, &prefixes_match?(module_path, &1, range)) + end + + def descendent_struct_modules(%__MODULE__{} = state, prefix, range_or_infinity) do + module_path = module_path(prefix) + + for struct_path <- state.struct_modules, + prefixes_match?(module_path, struct_path, range_or_infinity) do + Enum.join(struct_path, ".") + end + end + + defp module_path(module_name) do + module_name + |> Formats.module() + |> String.split(".") + end + + defp prefixes_match?([], _remainder, :infinity) do + true + end + + defp prefixes_match?([], remainder, %Range{} = range) do + length(remainder) in range + end + + defp prefixes_match?([same | haystack], [same | needle], range) do + prefixes_match?(haystack, needle, range) + end + + defp prefixes_match?(_, _, _) do + false + end + end + + alias Lexical.Project + alias Lexical.RemoteControl.Api + + use GenServer + import Api.Messages + + @generations [ + :self, + :child, + :grandchild, + :great_grandchild, + :great_great_grandchild, + :great_great_great_grandchild + ] + |> Enum.with_index() + |> Map.new() + + @type generation_name :: + :self + | :child + | :grandchild + | :great_grandchild + | :great_great_grandchild + | :great_great_great_grandchild + + @type module_spec :: module() | String.t() + @type module_name :: String.t() + @type generation_spec :: generation_name | non_neg_integer + @type generation_option :: {:from, generation_spec} | {:to, generation_spec} | {:to, :infinity} + @type generation_options :: [generation_option] + + # Public api + def start_link(%Project{} = project) do + GenServer.start_link(__MODULE__, [project], name: name(project)) + end + + @doc """ + Collects struct modules in the given ranges + + When given your project, and a root module, this function returns a list of module names + that fall within the given collection range. Given a module's descendent tree, a + range can be specified in the following ways: + + `named:` A keyword list contiaining `:from` (optional, defaults to `:self`) and + `:to` (optional, defaults to `:self`) keys. The values of these keys can be either + a number representing the degree of the descendent generation (o for self, 1 + for child, etc) or named generations (`:self`, `:child`, `:grandchild`, etc). For example, + the collectionn range: `from: :child, to: :great_grandchild` will collect all struct + modules where the root module is thier parent up to and including all modules where the + root module is their great grandparent, and is equivalent to the range `1..2`, + Of course, if you want to return all the struct_modules, you can simply use `to: :infinity`. + + `range`: A `Range` struct containing the starting and ending generations. The module passed in + as `root_module` is generation 0, its child is generation 1, its grandchild is generation 2, + and so on. + """ + @spec collect_struct_modules(Project.t(), module_spec) :: [module_name] + @spec collect_struct_modules(Project.t(), module_spec, generation_options | Range.t()) :: [ + module_name + ] + def collect_struct_modules(project, root_module, opts \\ []) + + def collect_struct_modules(%Project{} = project, root_module, opts) when is_list(opts) do + collect_struct_modules(project, root_module, extract_range(opts)) + end + + def collect_struct_modules(%Project{} = project, root_module, :infinity) do + project + |> name() + |> GenServer.call({:collect_struct_modules, root_module, :infinity}) + end + + def collect_struct_modules(%Project{} = project, root_module, %Range{} = range) do + project + |> name() + |> GenServer.call({:collect_struct_modules, root_module, range}) + end + + @doc """ + Returns true if a module in the given generation range defines a struct + + see `collect_struct_modules/3` for an explanation of generation ranges + """ + + @spec defines_struct?(Project.t(), module_spec) :: boolean + @spec defines_struct?(Project.t(), module_spec, generation_options | Range.t()) :: boolean + def defines_struct?(project, root_module, opts \\ []) + + def defines_struct?(%Project{} = project, root_module, opts) when is_list(opts) do + defines_struct?(project, root_module, extract_range(opts)) + end + + def defines_struct?(%Project{} = project, root_module, %Range{} = range) do + project + |> name() + |> GenServer.call({:defines_struct?, root_module, range}) + end + + def child_spec(%Project{} = project) do + %{ + id: {__MODULE__, Project.name(project)}, + start: {__MODULE__, :start_link, [project]} + } + end + + # GenServer callbacks + + @impl GenServer + def init([%Project{} = project]) do + Api.register_listener(project, self(), [ + project_index_ready(), + module_updated(), + struct_discovered() + ]) + + state = State.new(project) + {:ok, state} + end + + @impl GenServer + def handle_call({:defines_struct?, parent_module, %Range{} = range}, _from, %State{} = state) do + {:reply, State.descendent_defines_struct?(state, parent_module, range), state} + end + + @impl GenServer + def handle_call( + {:collect_struct_modules, parent_module, range_or_infinity}, + _from, + %State{} = state + ) do + {:reply, State.descendent_struct_modules(state, parent_module, range_or_infinity), state} + end + + @impl GenServer + def handle_info(module_updated(name: module_name, struct: nil), %State{} = state) do + state = State.delete_struct_module(state, module_name) + {:noreply, state} + end + + @impl GenServer + def handle_info(module_updated(name: module_name), %State{} = state) do + state = State.add_struct_module(state, module_name) + {:noreply, state} + end + + @impl GenServer + def handle_info(struct_discovered(module: module_name), %State{} = state) do + state = State.add_struct_module(state, module_name) + {:noreply, state} + end + + require Logger + + @impl GenServer + def handle_info(project_index_ready(), %State{} = state) do + {:ok, struct_definitions} = Api.struct_definitions(state.project) + + state = + Enum.reduce(struct_definitions, State.new(state.project), fn module, state -> + State.add_struct_module(state, module) + end) + + {:noreply, state} + end + + # Private + + def name(%Project{} = project) do + :"#{Project.name(project)}::intelligence" + end + + defp extract_range(to: :infinity) do + :infinity + end + + defp extract_range(opts) when is_list(opts) do + from = Keyword.get(opts, :from, :self) + from = Map.get(@generations, from, from) + + to = Keyword.get(opts, :to, :self) + to = Map.get(@generations, to, to) + + from..to + end +end diff --git a/expert/lib/lexical/server/project/node.ex b/expert/lib/lexical/server/project/node.ex new file mode 100644 index 00000000..222cf4bc --- /dev/null +++ b/expert/lib/lexical/server/project/node.ex @@ -0,0 +1,108 @@ +defmodule Expert.Project.Node do + @moduledoc """ + A genserver responsibile for starting the remote node and cleaning up the build directory if it crashes + """ + + defmodule State do + defstruct [:project, :node, :supervisor_pid] + + def new(project, node, supervisor_pid) do + %__MODULE__{project: project, node: node, supervisor_pid: supervisor_pid} + end + end + + alias Lexical.Project + alias Lexical.RemoteControl + alias Expert.Project.Progress + + require Logger + + use GenServer + use Progress.Support + + def start_link(%Project{} = project) do + GenServer.start_link(__MODULE__, project, name: name(project)) + end + + def child_spec(%Project{} = project) do + %{ + id: {__MODULE__, Project.name(project)}, + start: {__MODULE__, :start_link, [project]} + } + end + + def name(%Project{} = project) do + :"#{Project.name(project)}::node" + end + + def node_name(%Project{} = project) do + project + |> name() + |> GenServer.call(:node_name) + end + + def trigger_build(%Project{} = project) do + project + |> name() + |> GenServer.cast(:trigger_build) + end + + @impl GenServer + def init(%Project{} = project) do + case with_progress(project, "Project Node", fn -> start_node(project) end) do + {:ok, state} -> + {:ok, state, {:continue, :trigger_build}} + + error -> + {:stop, error} + end + end + + @impl GenServer + def handle_continue(:trigger_build, %State{} = state) do + RemoteControl.Api.schedule_compile(state.project, true) + {:noreply, state} + end + + @impl true + def handle_call(:node_name, _from, %State{} = state) do + {:reply, state.node, state} + end + + @impl GenServer + def handle_cast(:trigger_build, %State{} = state) do + RemoteControl.Api.schedule_compile(state.project, true) + {:noreply, state} + end + + @impl GenServer + def handle_info({:nodedown, _}, %State{} = state) do + Logger.warning("The node has died. Restarting after deleting the build directory") + + with :ok <- delete_build_artifacts(state.project), + {:ok, new_state} <- start_node(state.project) do + {:noreply, new_state} + else + error -> + {:stop, error, state} + end + end + + # private api + + def start_node(%Project{} = project) do + with {:ok, node, node_pid} <- RemoteControl.start_link(project) do + Node.monitor(node, true) + {:ok, State.new(project, node, node_pid)} + end + end + + defp delete_build_artifacts(%Project{} = project) do + build_path = RemoteControl.Build.path(project) + + case File.rm_rf(build_path) do + {:ok, _deleted} -> :ok + error -> error + end + end +end diff --git a/expert/lib/lexical/server/project/progress.ex b/expert/lib/lexical/server/project/progress.ex new file mode 100644 index 00000000..b812b126 --- /dev/null +++ b/expert/lib/lexical/server/project/progress.ex @@ -0,0 +1,46 @@ +defmodule Expert.Project.Progress do + alias Lexical.Project + alias Expert.Project.Progress.State + + import Lexical.RemoteControl.Api.Messages + + use GenServer + + def start_link(%Project{} = project) do + GenServer.start_link(__MODULE__, [project], name: name(project)) + end + + def child_spec(%Project{} = project) do + %{ + id: {__MODULE__, Project.name(project)}, + start: {__MODULE__, :start_link, [project]} + } + end + + # GenServer callbacks + + @impl GenServer + def init([project]) do + {:ok, State.new(project)} + end + + @impl true + def handle_info(project_progress(stage: stage) = message, %State{} = state) do + new_state = apply(State, stage, [state, message]) + {:noreply, new_state} + end + + def handle_info(percent_progress(stage: stage) = message, %State{} = state) do + new_state = apply(State, stage, [state, message]) + + {:noreply, new_state} + end + + def name(%Project{} = project) do + :"#{Project.name(project)}::progress" + end + + def whereis(%Project{} = project) do + project |> name() |> Process.whereis() + end +end diff --git a/expert/lib/lexical/server/project/progress/percentage.ex b/expert/lib/lexical/server/project/progress/percentage.ex new file mode 100644 index 00000000..f17ae430 --- /dev/null +++ b/expert/lib/lexical/server/project/progress/percentage.ex @@ -0,0 +1,67 @@ +defmodule Expert.Project.Progress.Percentage do + @moduledoc """ + The backing data structure for percentage based progress reports + """ + alias Lexical.Math + alias Lexical.Protocol.Notifications + alias Lexical.Protocol.Types.WorkDone + + @enforce_keys [:token, :kind, :max] + defstruct [:token, :kind, :title, :message, :max, current: 0] + + def begin(title, max) do + token = System.unique_integer([:positive]) + %__MODULE__{token: token, kind: :begin, title: title, max: max} + end + + def report(percentage, delta, message \\ "") + + def report(%__MODULE__{} = percentage, delta, message) when is_integer(delta) and delta >= 0 do + new_current = percentage.current + delta + + %__MODULE__{percentage | kind: :report, message: message, current: new_current} + end + + def report(%__MODULE__{} = percentage, delta, _message) when is_integer(delta) do + percentage + end + + def report(_, _, _) do + nil + end + + def complete(%__MODULE__{} = percentage, message) do + %__MODULE__{percentage | kind: :end, current: percentage.max, message: message} + end + + def to_protocol(%__MODULE__{kind: :begin} = value) do + Notifications.Progress.new( + token: value.token, + value: WorkDone.Progress.Begin.new(kind: "begin", title: value.title, percentage: 0) + ) + end + + def to_protocol(%__MODULE__{kind: :report} = value) do + percent_complete = + (value.current / value.max * 100) + |> round() + |> Math.clamp(0, 100) + + Notifications.Progress.new( + token: value.token, + value: + WorkDone.Progress.Report.new( + kind: "report", + message: value.message, + percentage: percent_complete + ) + ) + end + + def to_protocol(%__MODULE__{kind: :end} = value) do + Notifications.Progress.new( + token: value.token, + value: WorkDone.Progress.End.new(kind: "end", message: value.message) + ) + end +end diff --git a/expert/lib/lexical/server/project/progress/state.ex b/expert/lib/lexical/server/project/progress/state.ex new file mode 100644 index 00000000..9b88b3dc --- /dev/null +++ b/expert/lib/lexical/server/project/progress/state.ex @@ -0,0 +1,106 @@ +defmodule Expert.Project.Progress.State do + alias Lexical.Project + alias Lexical.Protocol.Id + alias Lexical.Protocol.Requests + alias Expert.Configuration + alias Expert.Project.Progress.Percentage + alias Expert.Project.Progress.Value + alias Expert.Transport + + import Lexical.RemoteControl.Api.Messages + + defstruct project: nil, progress_by_label: %{} + + def new(%Project{} = project) do + %__MODULE__{project: project} + end + + def begin(%__MODULE__{} = state, project_progress(label: label)) do + progress = Value.begin(label) + progress_by_label = Map.put(state.progress_by_label, label, progress) + + write_work_done(progress.token) + write(progress) + + %__MODULE__{state | progress_by_label: progress_by_label} + end + + def begin(%__MODULE__{} = state, percent_progress(label: label, max: max)) do + progress = Percentage.begin(label, max) + progress_by_label = Map.put(state.progress_by_label, label, progress) + write_work_done(progress.token) + write(progress) + + %__MODULE__{state | progress_by_label: progress_by_label} + end + + def report(%__MODULE__{} = state, project_progress(label: label, message: message)) do + {progress, progress_by_label} = + Map.get_and_update(state.progress_by_label, label, fn old_value -> + new_value = Value.report(old_value, message) + {new_value, new_value} + end) + + write(progress) + %__MODULE__{state | progress_by_label: progress_by_label} + end + + def report( + %__MODULE__{} = state, + percent_progress(label: label, message: message, delta: delta) + ) do + {progress, progress_by_label} = + Map.get_and_update(state.progress_by_label, label, fn old_percentage -> + new_percentage = Percentage.report(old_percentage, delta, message) + {new_percentage, new_percentage} + end) + + write(progress) + %__MODULE__{state | progress_by_label: progress_by_label} + end + + def complete(%__MODULE__{} = state, project_progress(label: label, message: message)) do + {progress, progress_by_label} = + Map.get_and_update(state.progress_by_label, label, fn _ -> :pop end) + + case progress do + %Value{} = progress -> + progress |> Value.complete(message) |> write + + _ -> + :ok + end + + %__MODULE__{state | progress_by_label: progress_by_label} + end + + def complete(%__MODULE__{} = state, percent_progress(label: label, message: message)) do + {progress, progress_by_label} = + Map.get_and_update(state.progress_by_label, label, fn _ -> :pop end) + + case progress do + %Percentage{} = progress -> + progress |> Percentage.complete(message) |> write() + + nil -> + :ok + end + + %__MODULE__{state | progress_by_label: progress_by_label} + end + + defp write_work_done(token) do + if Configuration.client_supports?(:work_done_progress) do + progress = Requests.CreateWorkDoneProgress.new(id: Id.next(), token: token) + Transport.write(progress) + end + end + + defp write(%progress_module{token: token} = progress) when not is_nil(token) do + if Configuration.client_supports?(:work_done_progress) do + progress |> progress_module.to_protocol() |> Transport.write() + end + end + + defp write(_), do: :ok +end diff --git a/expert/lib/lexical/server/project/progress/support.ex b/expert/lib/lexical/server/project/progress/support.ex new file mode 100644 index 00000000..e044954a --- /dev/null +++ b/expert/lib/lexical/server/project/progress/support.ex @@ -0,0 +1,42 @@ +defmodule Expert.Project.Progress.Support do + alias Lexical.Project + alias Expert.Project.Progress + + import Lexical.RemoteControl.Api.Messages + + defmacro __using__(_) do + quote do + import unquote(__MODULE__), only: [with_progress: 3] + end + end + + def with_progress(project, label, func) when is_function(func, 0) do + dest = Progress.name(project) + + try do + send(dest, project_progress(label: label, stage: :begin)) + func.() + after + send(dest, project_progress(label: label, stage: :complete)) + end + end + + def with_percentage_progress(%Project{} = project, label, max, func) + when is_function(func, 1) do + dest = Progress.name(project) + + report_progress = fn delta, message -> + message = + percent_progress(label: label, max: max, message: message, delta: delta, stage: :report) + + send(dest, message) + end + + try do + send(dest, percent_progress(label: label, max: max, stage: :begin)) + func.(report_progress) + after + send(dest, percent_progress(label: label, stage: :complete)) + end + end +end diff --git a/expert/lib/lexical/server/project/progress/value.ex b/expert/lib/lexical/server/project/progress/value.ex new file mode 100644 index 00000000..2bc2fdee --- /dev/null +++ b/expert/lib/lexical/server/project/progress/value.ex @@ -0,0 +1,45 @@ +defmodule Expert.Project.Progress.Value do + alias Lexical.Protocol.Notifications + alias Lexical.Protocol.Types.WorkDone + + @enforce_keys [:token, :kind] + defstruct [:token, :kind, :title, :message] + + def begin(title) do + token = System.unique_integer([:positive]) + %__MODULE__{token: token, kind: :begin, title: title} + end + + def report(%__MODULE__{token: token}, message) do + %__MODULE__{token: token, kind: :report, message: message} + end + + def report(_, _) do + nil + end + + def complete(%__MODULE__{token: token}, message) do + %__MODULE__{token: token, kind: :end, message: message} + end + + def to_protocol(%__MODULE__{kind: :begin} = value) do + Notifications.Progress.new( + token: value.token, + value: WorkDone.Progress.Begin.new(kind: "begin", title: value.title) + ) + end + + def to_protocol(%__MODULE__{kind: :report} = value) do + Notifications.Progress.new( + token: value.token, + value: WorkDone.Progress.Report.new(kind: "report", message: value.message) + ) + end + + def to_protocol(%__MODULE__{kind: :end} = value) do + Notifications.Progress.new( + token: value.token, + value: WorkDone.Progress.End.new(kind: "end", message: value.message) + ) + end +end diff --git a/expert/lib/lexical/server/project/search_listener.ex b/expert/lib/lexical/server/project/search_listener.ex new file mode 100644 index 00000000..69cf53c9 --- /dev/null +++ b/expert/lib/lexical/server/project/search_listener.ex @@ -0,0 +1,55 @@ +defmodule Expert.Project.SearchListener do + alias Lexical.Formats + alias Lexical.Project + alias Lexical.Protocol.Id + alias Lexical.Protocol.Requests + alias Lexical.RemoteControl.Api + alias Expert + alias Expert.Window + + import Api.Messages + + use GenServer + require Logger + + def start_link(%Project{} = project) do + GenServer.start_link(__MODULE__, [project], name: name(project)) + end + + defp name(%Project{} = project) do + :"#{Project.name(project)}::search_listener" + end + + @impl GenServer + def init([%Project{} = project]) do + Api.register_listener(project, self(), [ + project_reindex_requested(), + project_reindexed() + ]) + + {:ok, project} + end + + @impl GenServer + def handle_info(project_reindex_requested(), %Project{} = project) do + Logger.info("project reindex requested") + send_code_lens_refresh() + + {:noreply, project} + end + + def handle_info(project_reindexed(elapsed_ms: elapsed), %Project{} = project) do + message = "Reindexed #{Project.name(project)} in #{Formats.time(elapsed, unit: :millisecond)}" + Logger.info(message) + send_code_lens_refresh() + + Window.show_info_message(message) + + {:noreply, project} + end + + defp send_code_lens_refresh do + request = Requests.CodeLensRefresh.new(id: Id.next()) + Server.server_request(request) + end +end diff --git a/expert/lib/lexical/server/project/supervisor.ex b/expert/lib/lexical/server/project/supervisor.ex new file mode 100644 index 00000000..ed26ae23 --- /dev/null +++ b/expert/lib/lexical/server/project/supervisor.ex @@ -0,0 +1,53 @@ +defmodule Expert.Project.Supervisor do + alias Lexical.Project + alias Lexical.RemoteControl.ProjectNodeSupervisor + alias Expert.Project.Diagnostics + alias Expert.Project.Intelligence + alias Expert.Project.Node + alias Expert.Project.Progress + alias Expert.Project.SearchListener + + use Supervisor + + def dynamic_supervisor_name do + Expert.ProjectSupervisor + end + + def options do + [name: dynamic_supervisor_name(), strategy: :one_for_one] + end + + def start_link(%Project{} = project) do + Supervisor.start_link(__MODULE__, project, name: supervisor_name(project)) + end + + def init(%Project{} = project) do + children = [ + {Progress, project}, + {ProjectNodeSupervisor, project}, + {Node, project}, + {Diagnostics, project}, + {Intelligence, project}, + {SearchListener, project} + ] + + Supervisor.init(children, strategy: :one_for_one) + end + + def start(%Project{} = project) do + DynamicSupervisor.start_child(dynamic_supervisor_name(), {__MODULE__, project}) + end + + def stop(%Project{} = project) do + pid = + project + |> supervisor_name() + |> Process.whereis() + + DynamicSupervisor.terminate_child(dynamic_supervisor_name(), pid) + end + + defp supervisor_name(%Project{} = project) do + :"#{Project.name(project)}::supervisor" + end +end diff --git a/expert/lib/lexical/server/provider/handlers/code_action.ex b/expert/lib/lexical/server/provider/handlers/code_action.ex new file mode 100644 index 00000000..4e35828a --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/code_action.ex @@ -0,0 +1,41 @@ +defmodule Expert.Provider.Handlers.CodeAction do + alias Lexical.Protocol.Requests + alias Lexical.Protocol.Responses + alias Lexical.Protocol.Types + alias Lexical.Protocol.Types.Workspace + alias Lexical.RemoteControl + alias Lexical.RemoteControl.CodeAction + alias Expert.Configuration + + require Logger + + def handle(%Requests.CodeAction{} = request, %Configuration{} = config) do + diagnostics = Enum.map(request.context.diagnostics, &to_code_action_diagnostic/1) + + code_actions = + RemoteControl.Api.code_actions( + config.project, + request.document, + request.range, + diagnostics, + request.context.only || :all + ) + + results = Enum.map(code_actions, &to_result/1) + reply = Responses.CodeAction.new(request.id, results) + + {:reply, reply} + end + + defp to_code_action_diagnostic(%Types.Diagnostic{} = diagnostic) do + CodeAction.Diagnostic.new(diagnostic.range, diagnostic.message, diagnostic.source) + end + + defp to_result(%CodeAction{} = action) do + Types.CodeAction.new( + title: action.title, + kind: action.kind, + edit: Workspace.Edit.new(changes: %{action.uri => action.changes}) + ) + end +end diff --git a/expert/lib/lexical/server/provider/handlers/code_lens.ex b/expert/lib/lexical/server/provider/handlers/code_lens.ex new file mode 100644 index 00000000..7324f11d --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/code_lens.ex @@ -0,0 +1,58 @@ +defmodule Expert.Provider.Handlers.CodeLens do + alias Lexical.Document + alias Lexical.Document.Position + alias Lexical.Document.Range + alias Lexical.Project + alias Lexical.Protocol.Requests + alias Lexical.Protocol.Responses + alias Lexical.Protocol.Types.CodeLens + alias Lexical.RemoteControl + alias Expert.Configuration + alias Expert.Provider.Handlers + + import Document.Line + require Logger + + def handle(%Requests.CodeLens{} = request, %Configuration{} = config) do + lenses = + case reindex_lens(config.project, request.document) do + nil -> [] + lens -> List.wrap(lens) + end + + response = Responses.CodeLens.new(request.id, lenses) + {:reply, response} + end + + defp reindex_lens(%Project{} = project, %Document{} = document) do + if show_reindex_lens?(project, document) do + range = def_project_range(document) + command = Handlers.Commands.reindex_command(project) + + CodeLens.new(command: command, range: range) + end + end + + @project_regex ~r/def\s+project\s/ + defp def_project_range(%Document{} = document) do + # returns the line in mix.exs where `def project` occurs + Enum.reduce_while(document.lines, nil, fn + line(text: line_text, line_number: line_number), _ -> + if String.match?(line_text, @project_regex) do + start_pos = Position.new(document, line_number, 1) + end_pos = Position.new(document, line_number, String.length(line_text)) + range = Range.new(start_pos, end_pos) + {:halt, range} + else + {:cont, nil} + end + end) + end + + defp show_reindex_lens?(%Project{} = project, %Document{} = document) do + document_path = Path.expand(document.path) + + document_path == Project.mix_exs_path(project) and + not RemoteControl.Api.index_running?(project) + end +end diff --git a/expert/lib/lexical/server/provider/handlers/commands.ex b/expert/lib/lexical/server/provider/handlers/commands.ex new file mode 100644 index 00000000..a7e2bfe7 --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/commands.ex @@ -0,0 +1,60 @@ +defmodule Expert.Provider.Handlers.Commands do + alias Lexical.Project + alias Lexical.Protocol.Requests + alias Lexical.Protocol.Responses + alias Lexical.Protocol.Types + alias Lexical.Protocol.Types.ErrorCodes + alias Lexical.RemoteControl + alias Expert.Configuration + alias Expert.Window + + require ErrorCodes + require Logger + + @reindex_name "Reindex" + + def names do + [@reindex_name] + end + + def reindex_command(%Project{} = project) do + project_name = Project.name(project) + + Types.Command.new( + title: "Rebuild #{project_name}'s code search index", + command: @reindex_name + ) + end + + def handle(%Requests.ExecuteCommand{} = request, %Configuration{} = config) do + response = + case request.command do + @reindex_name -> + Logger.info("Reindex #{Project.name(config.project)}") + reindex(config.project, request.id) + + invalid -> + message = "#{invalid} is not a valid command" + internal_error(request.id, message) + end + + {:reply, response} + end + + defp reindex(%Project{} = project, request_id) do + case RemoteControl.Api.reindex(project) do + :ok -> + Responses.ExecuteCommand.new(request_id, "ok") + + error -> + Window.show_error_message("Indexing #{Project.name(project)} failed") + Logger.error("Indexing command failed due to #{inspect(error)}") + + internal_error(request_id, "Could not reindex: #{error}") + end + end + + defp internal_error(request_id, message) do + Responses.ExecuteCommand.error(request_id, :internal_error, message) + end +end diff --git a/expert/lib/lexical/server/provider/handlers/completion.ex b/expert/lib/lexical/server/provider/handlers/completion.ex new file mode 100644 index 00000000..0881cc43 --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/completion.ex @@ -0,0 +1,37 @@ +defmodule Expert.Provider.Handlers.Completion do + alias Lexical.Ast + alias Lexical.Document + alias Lexical.Document.Position + alias Lexical.Protocol.Requests + alias Lexical.Protocol.Responses + alias Lexical.Protocol.Types.Completion + alias Expert.CodeIntelligence + alias Expert.Configuration + + require Logger + + def handle(%Requests.Completion{} = request, %Configuration{} = config) do + completions = + CodeIntelligence.Completion.complete( + config.project, + document_analysis(request.document, request.position), + request.position, + request.context || Completion.Context.new(trigger_kind: :invoked) + ) + + response = Responses.Completion.new(request.id, completions) + {:reply, response} + end + + defp document_analysis(%Document{} = document, %Position{} = position) do + case Document.Store.fetch(document.uri, :analysis) do + {:ok, %Document{}, %Ast.Analysis{} = analysis} -> + Ast.reanalyze_to(analysis, position) + + _ -> + document + |> Ast.analyze() + |> Ast.reanalyze_to(position) + end + end +end diff --git a/expert/lib/lexical/server/provider/handlers/document_symbols.ex b/expert/lib/lexical/server/provider/handlers/document_symbols.ex new file mode 100644 index 00000000..0b47bdb5 --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/document_symbols.ex @@ -0,0 +1,58 @@ +defmodule Expert.Provider.Handlers.DocumentSymbols do + alias Lexical.Document + alias Lexical.Protocol.Requests.DocumentSymbols + alias Lexical.Protocol.Responses + alias Lexical.Protocol.Types.Document.Symbol + alias Lexical.Protocol.Types.Symbol.Kind, as: SymbolKind + alias Lexical.RemoteControl.Api + alias Lexical.RemoteControl.CodeIntelligence.Symbols + alias Expert.Configuration + + require SymbolKind + + def handle(%DocumentSymbols{} = request, %Configuration{} = config) do + symbols = + config.project + |> Api.document_symbols(request.document) + |> Enum.map(&to_response(&1, request.document)) + + response = Responses.DocumentSymbols.new(request.id, symbols) + + {:reply, response} + end + + def to_response(%Symbols.Document{} = root, %Document{} = document) do + children = + case root.children do + list when is_list(list) -> + Enum.map(list, &to_response(&1, document)) + + _ -> + nil + end + + Symbol.new( + children: children, + detail: root.detail, + kind: to_kind(root.type), + name: root.name, + range: root.range, + selection_range: root.detail_range + ) + end + + defp to_kind(:struct), do: :struct + defp to_kind(:module), do: :module + defp to_kind(:variable), do: :variable + defp to_kind({:function, _}), do: :function + defp to_kind({:protocol, _}), do: :module + defp to_kind(:module_attribute), do: :constant + defp to_kind(:ex_unit_test), do: :method + defp to_kind(:ex_unit_describe), do: :method + defp to_kind(:ex_unit_setup), do: :method + defp to_kind(:ex_unit_setup_all), do: :method + defp to_kind(:type), do: :type_parameter + defp to_kind(:spec), do: :interface + defp to_kind(:file), do: :file + defp to_kind(_), do: :string +end diff --git a/expert/lib/lexical/server/provider/handlers/find_references.ex b/expert/lib/lexical/server/provider/handlers/find_references.ex new file mode 100644 index 00000000..d5fa1eda --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/find_references.ex @@ -0,0 +1,26 @@ +defmodule Expert.Provider.Handlers.FindReferences do + alias Lexical.Ast + alias Lexical.Document + alias Lexical.Protocol.Requests.FindReferences + alias Lexical.Protocol.Responses + alias Lexical.RemoteControl.Api + alias Expert.Configuration + + require Logger + + def handle(%FindReferences{} = request, %Configuration{} = config) do + include_declaration? = !!request.context.include_declaration + + locations = + case Document.Store.fetch(request.document.uri, :analysis) do + {:ok, _document, %Ast.Analysis{} = analysis} -> + Api.references(config.project, analysis, request.position, include_declaration?) + + _ -> + nil + end + + response = Responses.FindReferences.new(request.id, locations) + {:reply, response} + end +end diff --git a/expert/lib/lexical/server/provider/handlers/formatting.ex b/expert/lib/lexical/server/provider/handlers/formatting.ex new file mode 100644 index 00000000..d18f2995 --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/formatting.ex @@ -0,0 +1,24 @@ +defmodule Expert.Provider.Handlers.Formatting do + alias Lexical.Document.Changes + alias Lexical.Protocol.Requests + alias Lexical.Protocol.Responses + alias Lexical.RemoteControl + alias Expert.Configuration + + require Logger + + def handle(%Requests.Formatting{} = request, %Configuration{} = config) do + document = request.document + + case RemoteControl.Api.format(config.project, document) do + {:ok, %Changes{} = document_edits} -> + response = Responses.Formatting.new(request.id, document_edits) + Logger.info("Response #{inspect(response)}") + {:reply, response} + + {:error, reason} -> + Logger.error("Formatter failed #{inspect(reason)}") + {:reply, Responses.Formatting.new(request.id, nil)} + end + end +end diff --git a/expert/lib/lexical/server/provider/handlers/go_to_definition.ex b/expert/lib/lexical/server/provider/handlers/go_to_definition.ex new file mode 100644 index 00000000..5f83da86 --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/go_to_definition.ex @@ -0,0 +1,19 @@ +defmodule Expert.Provider.Handlers.GoToDefinition do + alias Lexical.Protocol.Requests.GoToDefinition + alias Lexical.Protocol.Responses + alias Lexical.RemoteControl + alias Expert.Configuration + + require Logger + + def handle(%GoToDefinition{} = request, %Configuration{} = config) do + case RemoteControl.Api.definition(config.project, request.document, request.position) do + {:ok, native_location} -> + {:reply, Responses.GoToDefinition.new(request.id, native_location)} + + {:error, reason} -> + Logger.error("GoToDefinition failed: #{inspect(reason)}") + {:reply, Responses.GoToDefinition.new(request.id, nil)} + end + end +end diff --git a/expert/lib/lexical/server/provider/handlers/hover.ex b/expert/lib/lexical/server/provider/handlers/hover.ex new file mode 100644 index 00000000..1368ce34 --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/hover.ex @@ -0,0 +1,237 @@ +defmodule Expert.Provider.Handlers.Hover do + alias Lexical.Ast + alias Lexical.Ast.Analysis + alias Lexical.Document + alias Lexical.Document.Position + alias Lexical.Project + alias Lexical.Protocol.Requests + alias Lexical.Protocol.Responses + alias Lexical.Protocol.Types.Hover + alias Lexical.RemoteControl + alias Lexical.RemoteControl.CodeIntelligence.Docs + alias Expert.Configuration + alias Expert.Provider.Markdown + + require Logger + + def handle(%Requests.Hover{} = request, %Configuration{} = config) do + maybe_hover = + with {:ok, _document, %Ast.Analysis{} = analysis} <- + Document.Store.fetch(request.document.uri, :analysis), + {:ok, entity, range} <- resolve_entity(config.project, analysis, request.position), + {:ok, markdown} <- hover_content(entity, config.project) do + content = Markdown.to_content(markdown) + %Hover{contents: content, range: range} + else + error -> + Logger.warning("Could not resolve hover request, got: #{inspect(error)}") + nil + end + + {:reply, Responses.Hover.new(request.id, maybe_hover)} + end + + defp resolve_entity(%Project{} = project, %Analysis{} = analysis, %Position{} = position) do + RemoteControl.Api.resolve_entity(project, analysis, position) + end + + defp hover_content({kind, module}, %Project{} = project) when kind in [:module, :struct] do + case RemoteControl.Api.docs(project, module, exclude_hidden: false) do + {:ok, %Docs{} = module_docs} -> + header = module_header(kind, module_docs) + types = module_header_types(kind, module_docs) + + additional_sections = [ + module_doc(module_docs.doc), + module_footer(kind, module_docs) + ] + + if Enum.all?([types | additional_sections], &empty?/1) do + {:error, :no_doc} + else + header_block = "#{header}\n\n#{types}" |> String.trim() |> Markdown.code_block() + {:ok, Markdown.join_sections([header_block | additional_sections])} + end + + _ -> + {:error, :no_doc} + end + end + + defp hover_content({:call, module, fun, arity}, %Project{} = project) do + with {:ok, %Docs{} = module_docs} <- RemoteControl.Api.docs(project, module), + {:ok, entries} <- Map.fetch(module_docs.functions_and_macros, fun) do + sections = + entries + |> Enum.sort_by(& &1.arity) + |> Enum.filter(&(&1.arity >= arity)) + |> Enum.map(&entry_content/1) + + {:ok, Markdown.join_sections(sections, Markdown.separator())} + end + end + + defp hover_content({:type, module, type, arity}, %Project{} = project) do + with {:ok, %Docs{} = module_docs} <- RemoteControl.Api.docs(project, module), + {:ok, entries} <- Map.fetch(module_docs.types, type) do + case Enum.find(entries, &(&1.arity == arity)) do + %Docs.Entry{} = entry -> + {:ok, entry_content(entry)} + + _ -> + {:error, :no_type} + end + end + end + + defp hover_content(type, _) do + {:error, {:unsupported, type}} + end + + defp module_header(:module, %Docs{module: module}) do + Ast.Module.name(module) + end + + defp module_header(:struct, %Docs{module: module}) do + "%#{Ast.Module.name(module)}{}" + end + + defp module_header_types(:module, %Docs{}), do: "" + + defp module_header_types(:struct, %Docs{} = docs) do + docs.types + |> Map.get(:t, []) + |> sort_entries() + |> Enum.flat_map(& &1.defs) + |> Enum.join("\n\n") + end + + defp module_doc(s) when is_binary(s), do: s + defp module_doc(_), do: nil + + defp module_footer(:module, docs) do + callbacks = format_callbacks(docs.callbacks) + + unless empty?(callbacks) do + Markdown.section(callbacks, header: "Callbacks") + end + end + + defp module_footer(:struct, _docs), do: nil + + defp entry_content(%Docs.Entry{kind: fn_or_macro} = entry) + when fn_or_macro in [:function, :macro] do + call_header = call_header(entry) + specs = Enum.map_join(entry.defs, "\n", &("@spec " <> &1)) + + header = + [call_header, specs] + |> Markdown.join_sections() + |> String.trim() + |> Markdown.code_block() + + Markdown.join_sections([header, entry_doc_content(entry.doc)]) + end + + defp entry_content(%Docs.Entry{kind: :type} = entry) do + header = + Markdown.code_block(""" + #{call_header(entry)} + + #{type_defs(entry)}\ + """) + + Markdown.join_sections([header, entry_doc_content(entry.doc)]) + end + + @one_line_header_cutoff 50 + + defp call_header(%Docs.Entry{kind: :type} = entry) do + module_name = Ast.Module.name(entry.module) + + one_line_header = "#{module_name}.#{entry.name}/#{entry.arity}" + + two_line_header = + "#{last_module_name(module_name)}.#{entry.name}/#{entry.arity}\n#{module_name}" + + if String.length(one_line_header) >= @one_line_header_cutoff do + two_line_header + else + one_line_header + end + end + + defp call_header(%Docs.Entry{kind: maybe_macro} = entry) do + [signature | _] = entry.signature + module_name = Ast.Module.name(entry.module) + + macro_prefix = + if maybe_macro == :macro do + "(macro) " + else + "" + end + + one_line_header = "#{macro_prefix}#{module_name}.#{signature}" + + two_line_header = + "#{macro_prefix}#{last_module_name(module_name)}.#{signature}\n#{module_name}" + + if String.length(one_line_header) >= @one_line_header_cutoff do + two_line_header + else + one_line_header + end + end + + defp last_module_name(module_name) do + module_name + |> String.split(".") + |> List.last() + end + + defp type_defs(%Docs.Entry{metadata: %{opaque: true}} = entry) do + Enum.map_join(entry.defs, "\n", fn def -> + def + |> String.split("::", parts: 2) + |> List.first() + |> String.trim() + end) + end + + defp type_defs(%Docs.Entry{} = entry) do + Enum.join(entry.defs, "\n") + end + + defp format_callbacks(callbacks) do + callbacks + |> Map.values() + |> List.flatten() + |> sort_entries() + |> Enum.map_join("\n", fn %Docs.Entry{} = entry -> + header = + entry.defs + |> Enum.map_join("\n", &("@callback " <> &1)) + |> Markdown.code_block() + + if is_binary(entry.doc) do + """ + #{header} + #{entry_doc_content(entry.doc)} + """ + else + header + end + end) + end + + defp entry_doc_content(s) when is_binary(s), do: String.trim(s) + defp entry_doc_content(_), do: nil + + defp sort_entries(entries) do + Enum.sort_by(entries, &{&1.name, &1.arity}) + end + + defp empty?(empty) when empty in [nil, "", []], do: true + defp empty?(_), do: false +end diff --git a/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex b/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex new file mode 100644 index 00000000..7ad78bde --- /dev/null +++ b/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex @@ -0,0 +1,57 @@ +defmodule Expert.Provider.Handlers.WorkspaceSymbol do + alias Lexical.Protocol.Requests.WorkspaceSymbol + alias Lexical.Protocol.Responses + alias Lexical.Protocol.Types.Location + alias Lexical.Protocol.Types.Symbol.Kind, as: SymbolKind + alias Lexical.Protocol.Types.Workspace.Symbol + alias Lexical.RemoteControl.Api + alias Lexical.RemoteControl.CodeIntelligence.Symbols + alias Expert.Configuration + + require SymbolKind + + require Logger + + def handle(%WorkspaceSymbol{} = request, %Configuration{} = config) do + symbols = + if String.length(request.query) > 1 do + config.project + |> Api.workspace_symbols(request.query) + |> tap(fn symbols -> Logger.info("syms #{inspect(Enum.take(symbols, 5))}") end) + |> Enum.map(&to_response/1) + else + [] + end + + response = Responses.WorkspaceSymbol.new(request.id, symbols) + {:reply, response} + end + + def to_response(%Symbols.Workspace{} = root) do + Symbol.new( + kind: to_kind(root.type), + location: to_location(root.link), + name: root.name, + container_name: root.container_name + ) + end + + defp to_location(%Symbols.Workspace.Link{} = link) do + Location.new(uri: link.uri, range: link.detail_range) + end + + defp to_kind(:struct), do: :struct + defp to_kind(:module), do: :module + defp to_kind({:protocol, _}), do: :module + defp to_kind({:lx_protocol, _}), do: :module + defp to_kind(:variable), do: :variable + defp to_kind({:function, _}), do: :function + defp to_kind(:module_attribute), do: :constant + defp to_kind(:ex_unit_test), do: :method + defp to_kind(:ex_unit_describe), do: :method + defp to_kind(:ex_unit_setup), do: :method + defp to_kind(:ex_unit_setup_all), do: :method + defp to_kind(:type), do: :type_parameter + defp to_kind(:spec), do: :interface + defp to_kind(:file), do: :file +end diff --git a/expert/lib/lexical/server/provider/markdown.ex b/expert/lib/lexical/server/provider/markdown.ex new file mode 100644 index 00000000..ef35e06a --- /dev/null +++ b/expert/lib/lexical/server/provider/markdown.ex @@ -0,0 +1,84 @@ +defmodule Expert.Provider.Markdown do + @moduledoc """ + Utilities for formatting Markdown content. + """ + + alias Lexical.Protocol.Types.Markup + + @type markdown :: String.t() + + @doc """ + Converts a string of Markdown into LSP markup content. + """ + @spec to_content(markdown) :: Markup.Content.t() + def to_content(markdown) when is_binary(markdown) do + %Markup.Content{kind: :markdown, value: markdown} + end + + @doc """ + Wraps the content inside a Markdown code block. + + ## Options + + * `:lang` - The language for the block. Defaults to `"elixir"`. + + """ + @spec code_block(String.t(), [opt]) :: markdown + when opt: {:lang, String.t()} + def code_block(content, opts \\ []) do + lang = Keyword.get(opts, :lang, "elixir") + + """ + ```#{lang} + #{content} + ``` + """ + end + + @doc """ + Creates a Markdown section with a header. + + ## Options + + * `:header` (required) - The section title. + * `:header_level` - Defaults to `2`. + + """ + @spec section(markdown, [opt]) :: markdown + when opt: {:header, markdown} | {:header_level, pos_integer()} + def section(content, opts) do + header = Keyword.fetch!(opts, :header) + header_level = Keyword.get(opts, :header_level, 2) + + """ + #{String.duplicate("#", header_level)} #{header} + + #{content} + """ + end + + @doc """ + Joins multiple Markdown sections. + """ + @spec join_sections([markdown | nil]) :: markdown + def join_sections(sections, joiner \\ "\n\n") when is_list(sections) do + with_rules = + sections + |> Stream.filter(&(is_binary(&1) and &1 != "")) + |> Stream.map(&String.trim(&1)) + |> Enum.intersperse(joiner) + + case with_rules do + [] -> "" + _ -> IO.iodata_to_binary([with_rules, "\n"]) + end + end + + @doc """ + Returns a string that can be used to join sections with a horizontal rule. + """ + @spec separator() :: markdown + def separator do + "\n\n---\n\n" + end +end diff --git a/expert/lib/lexical/server/state.ex b/expert/lib/lexical/server/state.ex new file mode 100644 index 00000000..c99a49be --- /dev/null +++ b/expert/lib/lexical/server/state.ex @@ -0,0 +1,312 @@ +defmodule Expert.State do + alias Lexical.Document + alias Lexical.Protocol.Id + alias Lexical.Protocol.Notifications + alias Lexical.Protocol.Notifications.DidChange + alias Lexical.Protocol.Notifications.DidChangeConfiguration + alias Lexical.Protocol.Notifications.DidClose + alias Lexical.Protocol.Notifications.DidOpen + alias Lexical.Protocol.Notifications.DidSave + alias Lexical.Protocol.Notifications.Exit + alias Lexical.Protocol.Notifications.Initialized + alias Lexical.Protocol.Requests.Initialize + alias Lexical.Protocol.Requests.RegisterCapability + alias Lexical.Protocol.Requests.Shutdown + alias Lexical.Protocol.Responses + alias Lexical.Protocol.Types + alias Lexical.Protocol.Types.CodeAction + alias Lexical.Protocol.Types.CodeLens + alias Lexical.Protocol.Types.Completion + alias Lexical.Protocol.Types.DidChangeWatchedFiles + alias Lexical.Protocol.Types.ExecuteCommand + alias Lexical.Protocol.Types.FileEvent + alias Lexical.Protocol.Types.FileSystemWatcher + alias Lexical.Protocol.Types.Registration + alias Lexical.Protocol.Types.TextDocument + alias Lexical.RemoteControl + alias Lexical.RemoteControl.Api + alias Expert.CodeIntelligence + alias Expert.Configuration + alias Expert.Project + alias Expert.Provider.Handlers + alias Expert.Transport + + require CodeAction.Kind + require Logger + + import Api.Messages + + defstruct configuration: nil, + initialized?: false, + shutdown_received?: false, + in_flight_requests: %{} + + @supported_code_actions [ + :quick_fix, + :source_organize_imports + ] + + def new do + %__MODULE__{} + end + + def initialize(%__MODULE__{initialized?: false} = state, %Initialize{ + lsp: %Initialize.LSP{} = event + }) do + client_name = + case event.client_info do + %{name: name} -> name + _ -> nil + end + + config = Configuration.new(event.root_uri, event.capabilities, client_name) + new_state = %__MODULE__{state | configuration: config, initialized?: true} + Logger.info("Starting project at uri #{config.project.root_uri}") + + event.id + |> initialize_result() + |> Transport.write() + + Transport.write(registrations()) + + Project.Supervisor.start(config.project) + {:ok, new_state} + end + + def initialize(%__MODULE__{initialized?: true}, %Initialize{}) do + {:error, :already_initialized} + end + + def in_flight?(%__MODULE__{} = state, request_id) do + Map.has_key?(state.in_flight_requests, request_id) + end + + def add_request(%__MODULE__{} = state, request, callback) do + Transport.write(request) + + in_flight_requests = Map.put(state.in_flight_requests, request.id, {request, callback}) + + %__MODULE__{state | in_flight_requests: in_flight_requests} + end + + def finish_request(%__MODULE__{} = state, response) do + %{"id" => response_id} = response + + case Map.pop(state.in_flight_requests, response_id) do + {{%request_module{} = request, callback}, in_flight_requests} -> + case request_module.parse_response(response) do + {:ok, response} -> + callback.(request, {:ok, response.result}) + + error -> + Logger.info("failed to parse response for #{request_module}, #{inspect(error)}") + callback.(request, error) + end + + %__MODULE__{state | in_flight_requests: in_flight_requests} + + _ -> + state + end + end + + def default_configuration(%__MODULE__{configuration: config}) do + Configuration.default(config) + end + + def apply(%__MODULE__{initialized?: false}, request) do + Logger.error("Received #{request.method} before server was initialized") + {:error, :not_initialized} + end + + def apply(%__MODULE__{shutdown_received?: true} = state, %Exit{}) do + Logger.warning("Received an Exit notification. Halting the server in 150ms") + :timer.apply_after(50, System, :halt, [0]) + {:ok, state} + end + + def apply(%__MODULE__{shutdown_received?: true}, request) do + Logger.error("Received #{request.method} after shutdown. Ignoring") + {:error, :shutting_down} + end + + def apply(%__MODULE__{} = state, %DidChangeConfiguration{} = event) do + case Configuration.on_change(state.configuration, event) do + {:ok, config} -> + {:ok, %__MODULE__{state | configuration: config}} + + {:ok, config, response} -> + Transport.write(response) + {:ok, %__MODULE__{state | configuration: config}} + end + + {:ok, state} + end + + def apply(%__MODULE__{} = state, %DidChange{lsp: event}) do + uri = event.text_document.uri + version = event.text_document.version + project = state.configuration.project + + case Document.Store.get_and_update( + uri, + &Document.apply_content_changes(&1, version, event.content_changes) + ) do + {:ok, updated_source} -> + updated_message = + file_changed( + uri: updated_source.uri, + open?: true, + from_version: version, + to_version: updated_source.version + ) + + Api.broadcast(project, updated_message) + Api.compile_document(state.configuration.project, updated_source) + {:ok, state} + + error -> + error + end + end + + def apply(%__MODULE__{} = state, %DidOpen{} = did_open) do + %TextDocument.Item{ + text: text, + uri: uri, + version: version, + language_id: language_id + } = did_open.lsp.text_document + + case Document.Store.open(uri, text, version, language_id) do + :ok -> + Logger.info("opened #{uri}") + {:ok, state} + + error -> + Logger.error("Could not open #{uri} #{inspect(error)}") + error + end + end + + def apply(%__MODULE__{} = state, %DidClose{lsp: event}) do + uri = event.text_document.uri + + case Document.Store.close(uri) do + :ok -> + {:ok, state} + + error -> + Logger.warning( + "Received textDocument/didClose for a file that wasn't open. URI was #{uri}" + ) + + error + end + end + + def apply(%__MODULE__{} = state, %DidSave{lsp: event}) do + uri = event.text_document.uri + + case Document.Store.save(uri) do + :ok -> + Api.schedule_compile(state.configuration.project, false) + {:ok, state} + + error -> + Logger.error("Save failed for uri #{uri} error was #{inspect(error)}") + error + end + end + + def apply(%__MODULE__{} = state, %Initialized{}) do + Logger.info("Lexical Initialized") + {:ok, %__MODULE__{state | initialized?: true}} + end + + def apply(%__MODULE__{} = state, %Shutdown{} = shutdown) do + Transport.write(Responses.Shutdown.new(id: shutdown.id)) + Logger.error("Shutting down") + + {:ok, %__MODULE__{state | shutdown_received?: true}} + end + + def apply(%__MODULE__{} = state, %Notifications.DidChangeWatchedFiles{lsp: event}) do + project = state.configuration.project + + Enum.each(event.changes, fn %FileEvent{} = change -> + event = filesystem_event(project: Project, uri: change.uri, event_type: change.type) + RemoteControl.Api.broadcast(project, event) + end) + + {:ok, state} + end + + def apply(%__MODULE__{} = state, msg) do + Logger.error("Ignoring unhandled message: #{inspect(msg)}") + {:ok, state} + end + + defp registrations do + RegisterCapability.new(id: Id.next(), registrations: [file_watcher_registration()]) + end + + @did_changed_watched_files_id "-42" + @watched_extensions ~w(ex exs) + defp file_watcher_registration do + extension_glob = "{" <> Enum.join(@watched_extensions, ",") <> "}" + + watchers = [ + FileSystemWatcher.new(glob_pattern: "**/mix.lock"), + FileSystemWatcher.new(glob_pattern: "**/*.#{extension_glob}") + ] + + Registration.new( + id: @did_changed_watched_files_id, + method: "workspace/didChangeWatchedFiles", + register_options: DidChangeWatchedFiles.Registration.Options.new(watchers: watchers) + ) + end + + def initialize_result(event_id) do + sync_options = + TextDocument.Sync.Options.new(open_close: true, change: :incremental, save: true) + + code_action_options = + CodeAction.Options.new(code_action_kinds: @supported_code_actions, resolve_provider: false) + + code_lens_options = CodeLens.Options.new(resolve_provider: false) + + command_options = ExecuteCommand.Registration.Options.new(commands: Handlers.Commands.names()) + + completion_options = + Completion.Options.new(trigger_characters: CodeIntelligence.Completion.trigger_characters()) + + server_capabilities = + Types.ServerCapabilities.new( + code_action_provider: code_action_options, + code_lens_provider: code_lens_options, + completion_provider: completion_options, + definition_provider: true, + document_formatting_provider: true, + document_symbol_provider: true, + execute_command_provider: command_options, + hover_provider: true, + references_provider: true, + text_document_sync: sync_options, + workspace_symbol_provider: true + ) + + result = + Types.Initialize.Result.new( + capabilities: server_capabilities, + server_info: + Types.Initialize.Result.ServerInfo.new( + name: "Lexical", + version: "0.0.1" + ) + ) + + Responses.InitializeResult.new(event_id, result) + end +end diff --git a/expert/lib/lexical/server/task_queue.ex b/expert/lib/lexical/server/task_queue.ex new file mode 100644 index 00000000..bebcbd73 --- /dev/null +++ b/expert/lib/lexical/server/task_queue.ex @@ -0,0 +1,218 @@ +defmodule Expert.TaskQueue do + defmodule State do + alias Lexical.Proto.Convert + alias Lexical.Proto.LspTypes.ResponseError + alias Expert.Transport + import Lexical.Logging + require Logger + + defstruct ids_to_tasks: %{}, pids_to_ids: %{} + + @type t :: %__MODULE__{} + + def new do + %__MODULE__{} + end + + def task_supervisor_name do + __MODULE__.TaskSupervisor + end + + @spec add(t, request_id :: term(), mfa :: {module(), atom(), [term()]}) :: t + def add(%__MODULE__{} = state, request_id, {_, _, _} = mfa) do + task = %Task{} = as_task(request_id, mfa) + + %__MODULE__{ + state + | ids_to_tasks: Map.put(state.ids_to_tasks, request_id, task), + pids_to_ids: Map.put(state.pids_to_ids, task.pid, request_id) + } + end + + @spec cancel(t, request_id :: term()) :: t + def cancel(%__MODULE__{} = state, request_id) do + with {:ok, %Task{} = task} <- Map.fetch(state.ids_to_tasks, request_id), + :ok <- cancel_task(task) do + write_error(request_id, "Request cancelled", :request_cancelled) + + %__MODULE__{ + state + | ids_to_tasks: Map.delete(state.ids_to_tasks, request_id), + pids_to_ids: Map.delete(state.pids_to_ids, task.pid) + } + else + _ -> + state + end + end + + def size(%__MODULE__{} = state) do + map_size(state.ids_to_tasks) + end + + def task_finished(%__MODULE__{} = state, pid, reason) do + case Map.pop(state.pids_to_ids, pid) do + {nil, _} -> + state + + {request_id, new_pids_to_ids} -> + log_task_run_time(state.ids_to_tasks[request_id], :success) + maybe_log_task(reason, request_id) + + %__MODULE__{ + state + | pids_to_ids: new_pids_to_ids, + ids_to_tasks: Map.delete(state.ids_to_tasks, request_id) + } + end + end + + defp maybe_log_task(:normal, _), + do: :ok + + defp maybe_log_task(reason, request_id), + do: Logger.warning("Request id #{request_id} failed with reason #{inspect(reason)}") + + defp as_task(request_id, {m, f, a}) do + handler = fn -> + try do + case apply(m, f, a) do + :noreply -> + {:request_complete, request_id} + + {:reply, reply} -> + write_reply(reply) + + {:request_complete, request_id} + end + rescue + e -> + exception_string = Exception.format(:error, e, __STACKTRACE__) + Logger.error(exception_string) + write_error(request_id, exception_string) + + {:request_complete, request_id} + end + end + + run_task(handler, {m, f, a}) + end + + defp write_reply(response) do + case timed_log("convert", fn -> Convert.to_lsp(response) end) do + {:ok, lsp_response} -> + Transport.write(lsp_response) + + error -> + error_message = """ + Failed to convert #{response.__struct__}: + + #{inspect(error, pretty: true)}\ + """ + + Logger.critical(""" + #{error_message} + + #{inspect(response, pretty: true)}\ + """) + + write_error(response.id, error_message) + end + end + + defp write_error(id, message, code \\ :internal_error) do + error = ResponseError.new(code: code, message: message) + + Transport.write(%{id: id, error: error}) + end + + defp run_task(fun, mfa) when is_function(fun) do + task_supervisor_name() + |> Task.Supervisor.async_nolink(fun) + |> Map.merge(%{started_at: System.system_time(:microsecond), mfa: mfa}) + end + + defp cancel_task(%Task{} = task) do + log_task_run_time(task, :canceled) + Process.exit(task.pid, :canceled) + :ok + end + + defp log_task_run_time(%Task{} = task, result) do + case task do + %{started_at: ts, mfa: {m, f, a}} -> + elapsed = System.system_time(:microsecond) - ts + + Logger.warning( + "Task #{m}.#{f}/#{length(a)} ran for #{Lexical.Formats.time(elapsed)}. Result #{inspect(result)}" + ) + + _ -> + :ok + end + end + end + + use GenServer + + def task_supervisor_name do + State.task_supervisor_name() + end + + @spec add(request_id :: term(), mfa :: {module(), atom(), [term()]}) :: :ok + def add(request_id, {_, _, _} = mfa) do + GenServer.call(__MODULE__, {:add, request_id, mfa}) + end + + @spec size() :: non_neg_integer() + def size do + GenServer.call(__MODULE__, :size) + end + + def cancel(%{lsp: %{id: id}}) do + cancel(id) + end + + def cancel(%{id: request_id}) do + cancel(request_id) + end + + def cancel(request_id) do + GenServer.call(__MODULE__, {:cancel, request_id}) + end + + # genserver callbacks + + def start_link(_) do + GenServer.start_link(__MODULE__, [], name: __MODULE__) + end + + def init(_) do + {:ok, State.new()} + end + + def handle_call({:add, request_id, mfa}, _from, %State{} = state) do + new_state = State.add(state, request_id, mfa) + {:reply, :ok, new_state} + end + + def handle_call({:cancel, request_id}, _from, %State{} = state) do + new_state = State.cancel(state, request_id) + {:reply, :ok, new_state} + end + + def handle_call(:size, _from, %State{} = state) do + {:reply, State.size(state), state} + end + + def handle_info({:DOWN, _ref, :process, pid, reason}, state) do + new_state = State.task_finished(state, pid, reason) + {:noreply, new_state} + end + + def handle_info({ref, {:request_complete, _request_id}}, %State{} = state) + when is_reference(ref) do + # This head handles the replies from the tasks, which we don't really care about. + {:noreply, state} + end +end diff --git a/expert/lib/lexical/server/transport.ex b/expert/lib/lexical/server/transport.ex new file mode 100644 index 00000000..274715ee --- /dev/null +++ b/expert/lib/lexical/server/transport.ex @@ -0,0 +1,12 @@ +defmodule Expert.Transport do + @moduledoc """ + A behaviour for a LSP transport + """ + @callback write(Jason.Encoder.t()) :: Jason.Encoder.t() + + alias Expert.Transport.StdIO + + @implementation Application.compile_env(:server, :transport, StdIO) + + defdelegate write(message), to: @implementation +end diff --git a/expert/lib/lexical/server/transport/std_io.ex b/expert/lib/lexical/server/transport/std_io.ex new file mode 100644 index 00000000..6fc0bc2e --- /dev/null +++ b/expert/lib/lexical/server/transport/std_io.ex @@ -0,0 +1,145 @@ +defmodule Expert.Transport.StdIO do + alias Lexical.Protocol.JsonRpc + + require Logger + + @behaviour Expert.Transport + + def start_link(device, callback) do + pid = :proc_lib.spawn_link(__MODULE__, :init, [{callback, device}]) + {:ok, pid} + end + + def child_spec([device, callback]) do + %{id: __MODULE__, start: {__MODULE__, :start_link, [device, callback]}} + end + + def init({callback, device}) do + :io.setopts(binary: true, encoding: :latin1) + loop([], device, callback) + end + + def write(io_device \\ :stdio, payload) + + def write(io_device, %_{} = payload) do + with {:ok, lsp} <- Lexical.Proto.Convert.to_lsp(payload), + {:ok, json} <- Jason.encode(lsp) do + write(io_device, json) + end + end + + def write(io_device, %{} = payload) do + with {:ok, encoded} <- Jason.encode(payload) do + write(io_device, encoded) + end + end + + def write(io_device, payload) when is_binary(payload) do + message = + case io_device do + device when device in [:stdio, :standard_io] or is_pid(device) -> + {:ok, json_rpc} = JsonRpc.encode(payload) + json_rpc + + _ -> + payload + end + + IO.binwrite(io_device, message) + end + + def write(_, nil) do + end + + def write(_, []) do + end + + # private + + defp loop(buffer, device, callback) do + case IO.binread(device, :line) do + "\n" -> + headers = parse_headers(buffer) + + with {:ok, content_length} <- content_length(headers), + {:ok, data} <- read_body(device, content_length), + {:ok, message} <- JsonRpc.decode(data) do + callback.(message) + else + {:error, :empty_response} -> + :noop + + {:error, reason} -> + Logger.critical("read protocol message: #{inspect(reason)}") + end + + loop([], device, callback) + + :eof -> + Logger.critical("stdio received :eof, server will stop.") + maybe_stop() + + line -> + loop([line | buffer], device, callback) + end + end + + defp content_length(headers) do + with {:ok, len_str} <- find_header(headers, "content-length") do + parse_length(len_str) + end + end + + defp find_header(headers, name) do + case List.keyfind(headers, name, 0) do + {_, len_str} -> {:ok, len_str} + nil -> {:error, {:header_not_found, name}} + end + end + + defp parse_length(len_str) when is_binary(len_str) do + case Integer.parse(len_str) do + {int, ""} -> {:ok, int} + :error -> {:error, {:cant_parse_length, len_str}} + end + end + + defp read_body(device, byte_count) do + case IO.binread(device, byte_count) do + data when is_binary(data) -> + {:ok, data} + + :eof -> + Logger.critical("stdio received :eof, server will stop.") + maybe_stop() + + {:error, reason} -> + {:error, reason} + end + end + + defp parse_headers(headers) do + Enum.map(headers, &parse_header/1) + end + + defp parse_header(line) do + [name, value] = String.split(line, ":") + + header_name = + name + |> String.downcase() + |> String.trim() + + {header_name, String.trim(value)} + end + + if Mix.env() == :test do + defp maybe_stop do + :ok + end + else + defp maybe_stop do + System.stop() + end + end +end diff --git a/expert/lib/lexical/server/window.ex b/expert/lib/lexical/server/window.ex new file mode 100644 index 00000000..6247b374 --- /dev/null +++ b/expert/lib/lexical/server/window.ex @@ -0,0 +1,89 @@ +defmodule Expert.Window do + alias Lexical.Protocol.Id + alias Lexical.Protocol.Notifications.LogMessage + alias Lexical.Protocol.Notifications.ShowMessage + alias Lexical.Protocol.Requests + alias Lexical.Protocol.Types + alias Expert.Transport + + @type level :: :error | :warning | :info | :log + @type message_result :: {:errory, term()} | {:ok, nil} | {:ok, Types.Message.ActionItem.t()} + @type on_response_callback :: (message_result() -> any()) + @type message :: String.t() + @type action :: String.t() + + @levels [:error, :warning, :info, :log] + + @spec log(level, message()) :: :ok + def log(level, message) when level in @levels and is_binary(message) do + log_message = apply(LogMessage, level, [message]) + Transport.write(log_message) + :ok + end + + for level <- [:error, :warning, :info] do + def unquote(level)(message) do + log(unquote(level), message) + end + end + + @spec show(level(), message()) :: :ok + def show(level, message) when level in @levels and is_binary(message) do + show_message = apply(ShowMessage, level, [message]) + Transport.write(show_message) + :ok + end + + @spec show_message(level(), message()) :: :ok + def show_message(level, message) do + request = Requests.ShowMessageRequest.new(id: Id.next(), message: message, type: level) + Expert.server_request(request) + end + + for level <- @levels, + fn_name = :"show_#{level}_message" do + def unquote(fn_name)(message) do + show_message(unquote(level), message) + end + end + + for level <- @levels, + fn_name = :"show_#{level}_message" do + @doc """ + Shows a message at the #{level} level. Delegates to `show_message/4` + """ + def unquote(fn_name)(message, actions, on_response) when is_function(on_response, 1) do + show_message(unquote(level), message, actions, on_response) + end + end + + @doc """ + Shows a message request and handles the response + + Displays a message to the user in the UI and waits for a response. + The result type handed to the callback function is a + `Lexical.Protocol.Types.Message.ActionItem` or nil if there was no response + from the user. + + The strings passed in as the `actions` command are displayed to the user, and when + they select one, the `Types.Message.ActionItem` is passed to the callback function. + """ + @spec show_message(level(), message(), [action()], on_response_callback) :: :ok + def show_message(level, message, actions, on_response) + when is_function(on_response, 1) do + action_items = + Enum.map(actions, fn action_string -> + Types.Message.ActionItem.new(title: action_string) + end) + + request = + Requests.ShowMessageRequest.new( + id: Id.next(), + message: message, + actions: action_items, + type: level + ) + + Expert.server_request(request, fn _request, response -> on_response.(response) end) + end +end From 009d75dc6c8572597541bfab68595242a4cca64b Mon Sep 17 00:00:00 2001 From: Mitchell Hanberg Date: Sun, 5 Jan 2025 17:13:14 -0500 Subject: [PATCH 09/12] wip: move api messages to forge, rename some more aliases --- engine/lib/engine.ex | 6 - engine/lib/engine/api/proxy.ex | 2 +- .../lib/engine/api/proxy/buffering_state.ex | 2 +- engine/lib/engine/build/state.ex | 2 +- engine/lib/engine/commands/reindex.ex | 3 +- engine/lib/engine/compilation/tracer.ex | 2 +- engine/lib/engine/dispatch.ex | 2 +- engine/lib/engine/dispatch/handler.ex | 2 +- .../lib/engine/dispatch/handlers/indexing.ex | 2 +- engine/lib/engine/module_mappings.ex | 2 +- engine/lib/engine/progress.ex | 2 +- engine/lib/engine/search/store.ex | 2 +- engine/lib/engine/search/store/state.ex | 2 +- expert/lib/expert.ex | 1 - .../lib/engine => expert/lib/expert}/api.ex | 12 +- expert/lib/expert/application.ex | 13 +- .../lexical.plugin.diagnostic.result.ex | 8 +- expert/lib/lexical/server/application.ex | 64 ++++---- expert/lib/lexical/server/boot.ex | 149 ------------------ .../server/code_intelligence/completion.ex | 25 ++- .../code_intelligence/completion/builder.ex | 8 +- .../translations/bitstring_option.ex | 2 +- .../completion/translations/callable.ex | 2 +- .../completion/translations/callback.ex | 4 +- .../completion/translations/function.ex | 2 +- .../completion/translations/macro.ex | 6 +- .../completion/translations/map_field.ex | 2 +- .../translations/module_attribute.ex | 4 +- .../translations/module_or_behaviour.ex | 2 +- .../completion/translations/struct_field.ex | 2 +- .../completion/translations/typespec.ex | 2 +- .../completion/translations/variable.ex | 2 +- expert/lib/lexical/server/iex/helpers.ex | 28 ++-- .../lib/lexical/server/project/diagnostics.ex | 8 +- .../server/project/diagnostics/state.ex | 2 +- .../lexical/server/project/intelligence.ex | 4 +- expert/lib/lexical/server/project/node.ex | 10 +- expert/lib/lexical/server/project/progress.ex | 2 +- .../lexical/server/project/progress/state.ex | 2 +- .../server/project/progress/support.ex | 2 +- .../lexical/server/project/search_listener.ex | 4 +- .../lib/lexical/server/project/supervisor.ex | 2 +- .../server/provider/handlers/code_action.ex | 6 +- .../server/provider/handlers/code_lens.ex | 10 +- .../server/provider/handlers/commands.ex | 4 +- .../server/provider/handlers/completion.ex | 4 +- .../provider/handlers/document_symbols.ex | 6 +- .../provider/handlers/find_references.ex | 4 +- .../server/provider/handlers/formatting.ex | 6 +- .../provider/handlers/go_to_definition.ex | 4 +- .../lexical/server/provider/handlers/hover.ex | 16 +- .../provider/handlers/workspace_symbol.ex | 4 +- expert/lib/lexical/server/state.ex | 8 +- expert/lib/lexical/server/transport.ex | 12 -- expert/lib/lexical/server/transport/std_io.ex | 145 ----------------- expert/lib/lexical/server/window.ex | 89 ----------- expert/mix.exs | 1 + expert/mix.lock | 2 + .../lib/forge}/api/messages.ex | 2 +- 59 files changed, 164 insertions(+), 564 deletions(-) rename {engine/lib/engine => expert/lib/expert}/api.ex (93%) delete mode 100644 expert/lib/lexical/server/boot.ex delete mode 100644 expert/lib/lexical/server/transport.ex delete mode 100644 expert/lib/lexical/server/transport/std_io.ex delete mode 100644 expert/lib/lexical/server/window.ex rename {engine/lib/engine => forge/lib/forge}/api/messages.ex (99%) diff --git a/engine/lib/engine.ex b/engine/lib/engine.ex index 95fe0164..c3a60d5d 100644 --- a/engine/lib/engine.ex +++ b/engine/lib/engine.ex @@ -93,12 +93,6 @@ defmodule Engine do defdelegate stop(project), to: ProjectNode - def call(%Project{} = project, m, f, a \\ []) do - project - |> Project.node_name() - |> :erpc.call(m, f, a) - end - def manager_node_name(%Project{} = project) do :"manager-#{Project.name(project)}-#{Project.entropy(project)}@127.0.0.1" end diff --git a/engine/lib/engine/api/proxy.ex b/engine/lib/engine/api/proxy.ex index 9b669d24..6cebd5f5 100644 --- a/engine/lib/engine/api/proxy.ex +++ b/engine/lib/engine/api/proxy.ex @@ -33,7 +33,7 @@ defmodule Engine.Api.Proxy do alias Forge.Document alias Forge.Document.Changes - alias Engine.Api.Messages + alias Forge.Api.Messages alias Engine.Api.Proxy.BufferingState alias Engine.Api.Proxy.DrainingState alias Engine.Api.Proxy.ProxyingState diff --git a/engine/lib/engine/api/proxy/buffering_state.ex b/engine/lib/engine/api/proxy/buffering_state.ex index 6cd23c40..8abf051a 100644 --- a/engine/lib/engine/api/proxy/buffering_state.ex +++ b/engine/lib/engine/api/proxy/buffering_state.ex @@ -5,7 +5,7 @@ defmodule Engine.Api.Proxy.BufferingState do alias Engine.Build alias Engine.Commands - import Api.Messages + import Forge.Api.Messages import Api.Proxy.Records defstruct initiator_pid: nil, buffer: [] diff --git a/engine/lib/engine/build/state.ex b/engine/lib/engine/build/state.ex index eeac1840..76f95e8f 100644 --- a/engine/lib/engine/build/state.ex +++ b/engine/lib/engine/build/state.ex @@ -3,7 +3,7 @@ defmodule Engine.Build.State do alias Forge.Document alias Forge.Project - alias Engine.Api.Messages + alias Forge.Api.Messages alias Engine.Build alias Forge.VM.Versions diff --git a/engine/lib/engine/commands/reindex.ex b/engine/lib/engine/commands/reindex.ex index bd5e06f9..3590f85f 100644 --- a/engine/lib/engine/commands/reindex.ex +++ b/engine/lib/engine/commands/reindex.ex @@ -73,11 +73,10 @@ defmodule Engine.Commands.Reindex do alias Forge.Document alias Forge.Project - alias Engine.Api alias Engine.Search use GenServer - import Api.Messages + import Forge.Api.Messages def start_link(opts) do [reindex_fun: fun] = Keyword.validate!(opts, reindex_fun: &do_reindex/1) diff --git a/engine/lib/engine/compilation/tracer.ex b/engine/lib/engine/compilation/tracer.ex index d4b3a59d..45ac9582 100644 --- a/engine/lib/engine/compilation/tracer.ex +++ b/engine/lib/engine/compilation/tracer.ex @@ -2,7 +2,7 @@ defmodule Engine.Compilation.Tracer do alias Engine.Build alias Engine.Module.Loader - import Engine.Api.Messages + import Forge.Api.Messages def trace({:on_module, module_binary, _filename}, %Macro.Env{} = env) do message = extract_module_updated(env.module, module_binary, env.file) diff --git a/engine/lib/engine/dispatch.ex b/engine/lib/engine/dispatch.ex index 5ac34565..6ba31581 100644 --- a/engine/lib/engine/dispatch.ex +++ b/engine/lib/engine/dispatch.ex @@ -9,7 +9,7 @@ defmodule Engine.Dispatch do alias Engine.Dispatch.Handlers alias Engine.Dispatch.PubSub - import Engine.Api.Messages + import Forge.Api.Messages @handlers [PubSub, Handlers.Indexing] diff --git a/engine/lib/engine/dispatch/handler.ex b/engine/lib/engine/dispatch/handler.ex index 47d4fcbc..b580ac75 100644 --- a/engine/lib/engine/dispatch/handler.ex +++ b/engine/lib/engine/dispatch/handler.ex @@ -7,7 +7,7 @@ defmodule Engine.Dispatch.Handler do Define a handler, specifying the events to be handled and implementing `on_event/2`: defmodule MyHandler do - alias Engine.Api.Messages + alias Forge.Api.Messages alias Engine.Dispatch.Handler import Messages diff --git a/engine/lib/engine/dispatch/handlers/indexing.ex b/engine/lib/engine/dispatch/handlers/indexing.ex index 7223ec57..f9d2e34e 100644 --- a/engine/lib/engine/dispatch/handlers/indexing.ex +++ b/engine/lib/engine/dispatch/handlers/indexing.ex @@ -1,6 +1,6 @@ defmodule Engine.Dispatch.Handlers.Indexing do alias Forge.Document - alias Engine.Api.Messages + alias Forge.Api.Messages alias Engine.Commands alias Engine.Dispatch alias Engine.Search diff --git a/engine/lib/engine/module_mappings.ex b/engine/lib/engine/module_mappings.ex index c2090dee..05f34c32 100644 --- a/engine/lib/engine/module_mappings.ex +++ b/engine/lib/engine/module_mappings.ex @@ -39,7 +39,7 @@ defmodule Engine.ModuleMappings do end end - alias Engine.Api.Messages + alias Forge.Api.Messages use GenServer diff --git a/engine/lib/engine/progress.ex b/engine/lib/engine/progress.ex index ab24e5e8..1f977e35 100644 --- a/engine/lib/engine/progress.ex +++ b/engine/lib/engine/progress.ex @@ -1,5 +1,5 @@ defmodule Engine.Progress do - import Engine.Api.Messages + import Forge.Api.Messages @type label :: String.t() @type message :: String.t() diff --git a/engine/lib/engine/search/store.ex b/engine/lib/engine/search/store.ex index 4d4fa6a0..0cede683 100644 --- a/engine/lib/engine/search/store.ex +++ b/engine/lib/engine/search/store.ex @@ -5,7 +5,7 @@ defmodule Engine.Search.Store do alias Forge.Project - alias Engine.Api + alias Forge.Api alias Engine.Search.Indexer.Entry alias Engine.Search.Store alias Engine.Search.Store.State diff --git a/engine/lib/engine/search/store/state.ex b/engine/lib/engine/search/store/state.ex index df811386..e3ad0c3f 100644 --- a/engine/lib/engine/search/store/state.ex +++ b/engine/lib/engine/search/store/state.ex @@ -1,6 +1,6 @@ defmodule Engine.Search.Store.State do alias Forge.Project - alias Engine.Api.Messages + alias Forge.Api.Messages alias Engine.Dispatch alias Engine.Search.Fuzzy alias Engine.Search.Indexer.Entry diff --git a/expert/lib/expert.ex b/expert/lib/expert.ex index 7401abe0..a65cd2da 100644 --- a/expert/lib/expert.ex +++ b/expert/lib/expert.ex @@ -3,7 +3,6 @@ defmodule Expert do alias GenLSP.Structures.CodeActionOptions use GenLSP - alias GenLSP.Structures.WorkspaceFoldersServerCapabilities alias GenLSP.Enumerations.TextDocumentSyncKind alias GenLSP.Structures.SaveOptions alias GenLSP.Structures.TextDocumentSyncOptions diff --git a/engine/lib/engine/api.ex b/expert/lib/expert/api.ex similarity index 93% rename from engine/lib/engine/api.ex rename to expert/lib/expert/api.ex index 769cc3c5..4510dd1e 100644 --- a/engine/lib/engine/api.ex +++ b/expert/lib/expert/api.ex @@ -1,4 +1,4 @@ -defmodule Engine.Api do +defmodule Expert.Api do alias Forge.Ast.Analysis alias Forge.Ast.Env alias Forge.Document @@ -11,11 +11,17 @@ defmodule Engine.Api do require Logger def schedule_compile(%Project{} = project, force?) do - Engine.call(project, Engine, :schedule_compile, [force?]) + call(project, Engine, :schedule_compile, [force?]) end def compile_document(%Project{} = project, %Document{} = document) do - Engine.call(project, Engine, :compile_document, [document]) + call(project, Engine, :compile_document, [document]) + end + + def call(%Project{} = project, m, f, a \\ []) do + project + |> Forge.Project.node_name() + |> :erpc.call(m, f, a) end def expand_alias( diff --git a/expert/lib/expert/application.ex b/expert/lib/expert/application.ex index f4cdd0a3..3aa093ef 100644 --- a/expert/lib/expert/application.ex +++ b/expert/lib/expert/application.ex @@ -5,7 +5,6 @@ defmodule Expert.Application do use Application - @impl true def start(_type, _args) do case System.cmd("epmd", ["-daemon"], stderr_to_stdout: true) do @@ -21,12 +20,12 @@ defmodule Expert.Application do Node.start(:"expert-#{System.system_time()}", :shortnames) children = [ - document_store_child_spec(), - Expert.LSPSupervisor - {DynamicSupervisor, Server.Project.Supervisor.options()}, - {Task.Supervisor, name: TaskQueue.task_supervisor_name()}, - TaskQueue, - ] + {Forge.Document.Store, derive: [analysis: &Forge.Ast.analyze/1]}, + Expert.LSPSupervisor, + {DynamicSupervisor, Expert.Project.Supervisor.options()}, + {Task.Supervisor, name: Expert.TaskQueue.task_supervisor_name()}, + TaskQueue + ] # See https://hexdocs.pm/elixir/Supervisor.html # for other strategies and supported options diff --git a/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex b/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex index e6251213..1b48f0d5 100644 --- a/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex +++ b/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex @@ -1,7 +1,7 @@ -defimpl Lexical.Convertible, for: Lexical.Plugin.V1.Diagnostic.Result do - alias Lexical.Document - alias Lexical.Document.Position - alias Lexical.Document.Range +defimpl Forge.Convertible, for: Forge.Plugin.V1.Diagnostic.Result do + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range alias Lexical.Math alias Lexical.Plugin.V1.Diagnostic alias Lexical.Protocol.Conversions diff --git a/expert/lib/lexical/server/application.ex b/expert/lib/lexical/server/application.ex index bff7d20d..204b2593 100644 --- a/expert/lib/lexical/server/application.ex +++ b/expert/lib/lexical/server/application.ex @@ -1,32 +1,32 @@ -defmodule Expert.Application do - # See https://hexdocs.pm/elixir/Application.html - # for more information on OTP Applications - @moduledoc false - - alias Lexical.Document - alias Expert - alias Expert.TaskQueue - alias Expert.Transport - - use Application - - @impl true - def start(_type, _args) do - children = [ - document_store_child_spec(), - Server, - {DynamicSupervisor, Server.Project.Supervisor.options()}, - {Task.Supervisor, name: TaskQueue.task_supervisor_name()}, - TaskQueue, - {Transport.StdIO, [:standard_io, &Server.protocol_message/1]} - ] - - opts = [strategy: :one_for_one, name: Server.Supervisor] - Supervisor.start_link(children, opts) - end - - @doc false - def document_store_child_spec do - {Document.Store, derive: [analysis: &Lexical.Ast.analyze/1]} - end -end +# defmodule Expert.Application do +# # See https://hexdocs.pm/elixir/Application.html +# # for more information on OTP Applications +# @moduledoc false +# +# alias Forge.Document +# alias Expert +# alias Expert.TaskQueue +# alias Expert.Transport +# +# use Application +# +# @impl true +# def start(_type, _args) do +# children = [ +# document_store_child_spec(), +# Server, +# {DynamicSupervisor, Server.Project.Supervisor.options()}, +# {Task.Supervisor, name: TaskQueue.task_supervisor_name()}, +# TaskQueue, +# {Transport.StdIO, [:standard_io, &Server.protocol_message/1]} +# ] +# +# opts = [strategy: :one_for_one, name: Server.Supervisor] +# Supervisor.start_link(children, opts) +# end +# +# @doc false +# def document_store_child_spec do +# {Document.Store, derive: [analysis: &Lexical.Ast.analyze/1]} +# end +# end diff --git a/expert/lib/lexical/server/boot.ex b/expert/lib/lexical/server/boot.ex deleted file mode 100644 index 7cf5f707..00000000 --- a/expert/lib/lexical/server/boot.ex +++ /dev/null @@ -1,149 +0,0 @@ -defmodule Expert.Boot do - @moduledoc """ - This module is called when the server starts by the start script. - - Packaging will ensure that config.exs and runtime.exs will be visible to the `:code` module - """ - alias Future.Code - alias Lexical.VM.Versions - require Logger - - # halt/1 will generate a "no local return" error, which is exactly right, but that's it's _job_ - @dialyzer {:nowarn_function, halt: 1} - - @env Mix.env() - @target Mix.target() - @dep_apps Enum.map(Mix.Dep.cached(), & &1.app) - - def start do - {:ok, _} = Application.ensure_all_started(:mix) - - Application.stop(:logger) - load_config() - Application.ensure_all_started(:logger) - - Enum.each(@dep_apps, &load_app_modules/1) - - case detect_errors() do - [] -> - :ok - - errors -> - errors - |> Enum.join("\n\n") - |> halt() - end - - Application.ensure_all_started(:server) - end - - @doc false - def detect_errors do - versioning_errors() - end - - defp load_config do - config = read_config("config.exs") - runtime = read_config("runtime.exs") - merged_config = Config.Reader.merge(config, runtime) - apply_config(merged_config) - end - - defp apply_config(configs) do - for {app_name, keywords} <- configs, - {config_key, config_value} <- keywords do - Application.put_env(app_name, config_key, config_value) - end - end - - defp read_config(file_name) do - case where_is_file(String.to_charlist(file_name)) do - {:ok, path} -> - Config.Reader.read!(path, env: @env, target: @target) - - _ -> - [] - end - end - - defp where_is_file(file_name) do - case :code.where_is_file(file_name) do - :non_existing -> - :error - - path -> - {:ok, List.to_string(path)} - end - end - - defp load_app_modules(app_name) do - Application.ensure_loaded(app_name) - modules = Application.spec(app_name, :modules) - Code.ensure_all_loaded!(modules) - end - - @allowed_elixir %{ - "1.13.0" => ">= 1.13.0", - "1.14.0" => ">= 1.14.0", - "1.15.0" => ">= 1.15.3", - "1.16.0" => ">= 1.16.0", - "1.17.0-rc" => ">= 1.17.0-rc", - "1.17.0" => ">= 1.17.0" - } - @allowed_erlang %{ - "24" => ">= 24.3.4", - "25" => ">= 25.0.0", - "26" => ">= 26.0.2", - "27" => ">= 27.0.0" - } - - defp versioning_errors do - versions = Versions.to_versions(Versions.current()) - - elixir_base = to_string(%Version{versions.elixir | patch: 0}) - erlang_base = to_string(versions.erlang.major) - - detected_elixir_range = Map.get(@allowed_elixir, elixir_base, false) - detected_erlang_range = Map.get(@allowed_erlang, erlang_base, false) - - elixir_ok? = detected_elixir_range && Version.match?(versions.elixir, detected_elixir_range) - erlang_ok? = detected_erlang_range && Version.match?(versions.erlang, detected_erlang_range) - - errors = [ - unless elixir_ok? do - """ - FATAL: Lexical is not compatible with Elixir #{versions.elixir} - - Lexical is compatible with the following versions of Elixir: - - #{format_allowed_versions(@allowed_elixir)} - """ - end, - unless erlang_ok? do - """ - FATAL: Lexical is not compatible with Erlang/OTP #{versions.erlang} - - Lexical is compatible with the following versions of Erlang/OTP: - - #{format_allowed_versions(@allowed_erlang)} - """ - end - ] - - Enum.filter(errors, &Function.identity/1) - end - - defp format_allowed_versions(%{} = versions) do - versions - |> Map.values() - |> Enum.sort() - |> Enum.map_join("\n", fn range -> " #{range}" end) - end - - defp halt(message) do - Mix.Shell.IO.error(message) - Logger.emergency(message) - Logger.flush() - System.halt() - end -end diff --git a/expert/lib/lexical/server/code_intelligence/completion.ex b/expert/lib/lexical/server/code_intelligence/completion.ex index 2198a35e..e273e203 100644 --- a/expert/lib/lexical/server/code_intelligence/completion.ex +++ b/expert/lib/lexical/server/code_intelligence/completion.ex @@ -1,20 +1,15 @@ defmodule Expert.CodeIntelligence.Completion do alias Future.Code, as: Code - alias Lexical.Ast.Analysis - alias Lexical.Ast.Env - alias Lexical.Document.Position - alias Lexical.Project - alias Lexical.Protocol.Types.Completion - alias Lexical.Protocol.Types.InsertTextFormat - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Completion.Candidate + alias Forge.Ast.Analysis + alias Forge.Ast.Env + alias Forge.Document.Position + alias Forge.Project + alias Engine.Completion.Candidate alias Expert.CodeIntelligence.Completion.Builder alias Expert.CodeIntelligence.Completion.Translatable alias Expert.Configuration alias Expert.Project.Intelligence - alias Mix.Tasks.Namespace - require InsertTextFormat require Logger @lexical_deps Enum.map([:lexical | Mix.Project.deps_apps()], &Atom.to_string/1) @@ -78,12 +73,12 @@ defmodule Expert.CodeIntelligence.Completion do Env.in_context?(env, :struct_field_key) -> project - |> RemoteControl.Api.complete_struct_fields(env.analysis, env.position) + |> Engine.Api.complete_struct_fields(env.analysis, env.position) |> Enum.map(&Translatable.translate(&1, Builder, env)) true -> project - |> RemoteControl.Api.complete(env) + |> Engine.Api.complete(env) |> to_completion_items(project, env, context) end end @@ -271,7 +266,7 @@ defmodule Expert.CodeIntelligence.Completion do case completion do %{full_name: full_name} -> with_prefix = - RemoteControl.Api.modules_with_prefix( + Engine.Api.modules_with_prefix( env.project, full_name, {Kernel, :macro_exported?, [:__using__, 1]} @@ -291,7 +286,7 @@ defmodule Expert.CodeIntelligence.Completion do case completion do %{full_name: full_name} -> with_prefix = - RemoteControl.Api.modules_with_prefix( + Engine.Api.modules_with_prefix( env.project, full_name, {Kernel, :function_exported?, [:behaviour_info, 1]} @@ -326,7 +321,7 @@ defmodule Expert.CodeIntelligence.Completion do end defp typespec_or_type_candidate?(%Candidate.Function{} = function, %Env{} = env) do - case RemoteControl.Api.expand_alias(env.project, [:__MODULE__], env.analysis, env.position) do + case Engine.Api.expand_alias(env.project, [:__MODULE__], env.analysis, env.position) do {:ok, expanded} -> expanded == function.origin diff --git a/expert/lib/lexical/server/code_intelligence/completion/builder.ex b/expert/lib/lexical/server/code_intelligence/completion/builder.ex index 35f0e6e3..e0c11ae8 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/builder.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/builder.ex @@ -12,10 +12,10 @@ defmodule Expert.CodeIntelligence.Completion.Builder do alias Future.Code, as: Code alias Lexical.Ast.Env - alias Lexical.Document - alias Lexical.Document.Edit - alias Lexical.Document.Position - alias Lexical.Document.Range + alias Forge.Document + alias Forge.Document.Edit + alias Forge.Document.Position + alias Forge.Document.Range alias Lexical.Protocol.Types.Completion alias Lexical.Protocol.Types.Markup.Content alias Expert.CodeIntelligence.Completion.SortScope diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex index 4adb2f48..c74ef057 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.BitstringOption do alias Lexical.Ast.Env - alias Lexical.RemoteControl.Completion.Candidate + alias Engine.Completion.Candidate alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex index dd9064b8..f8ee159f 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Callable do alias Lexical.Ast.Env - alias Lexical.RemoteControl.Completion.Candidate + alias Engine.Completion.Candidate alias Expert.CodeIntelligence.Completion.Builder alias Expert.CodeIntelligence.Completion.SortScope diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex index 3805e902..d7e06b69 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex @@ -1,7 +1,7 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Callback do alias Lexical.Ast.Env - alias Lexical.Document - alias Lexical.RemoteControl.Completion.Candidate.Callback + alias Forge.Document + alias Engine.Completion.Candidate.Callback alias Expert.CodeIntelligence.Completion.Builder alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex index 7c5ff947..e995c92c 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Function do alias Lexical.Ast.Env - alias Lexical.RemoteControl.Completion.Candidate + alias Engine.Completion.Candidate alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex index 01b35b41..26b21517 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex @@ -1,9 +1,9 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Macro do alias Lexical.Ast alias Lexical.Ast.Env - alias Lexical.Document - alias Lexical.Document.Position - alias Lexical.RemoteControl.Completion.Candidate + alias Forge.Document + alias Forge.Document.Position + alias Engine.Completion.Candidate alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex index 8117ec89..4b7f2bd2 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.MapField do alias Lexical.Ast.Env - alias Lexical.RemoteControl.Completion.Candidate + alias Engine.Completion.Candidate alias Expert.CodeIntelligence.Completion.Translatable defimpl Translatable, for: Candidate.MapField do diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex index 2845dc07..6d26980f 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex @@ -1,8 +1,8 @@ defmodule Expert.CodeIntelligence.Completion.Translations.ModuleAttribute do alias Lexical.Ast alias Lexical.Ast.Env - alias Lexical.Document.Position - alias Lexical.RemoteControl.Completion.Candidate + alias Forge.Document.Position + alias Engine.Completion.Candidate alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex index bc29fd2a..6ea79f86 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.ModuleOrBehaviour do alias Lexical.Ast.Env - alias Lexical.RemoteControl.Completion.Candidate + alias Engine.Completion.Candidate alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex index 0521051e..71173333 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex @@ -1,7 +1,7 @@ defmodule Expert.CodeIntelligence.Completion.Translations.StructField do alias Future.Code, as: Code alias Lexical.Ast.Env - alias Lexical.RemoteControl.Completion.Candidate + alias Engine.Completion.Candidate alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex index fd6bdf58..62dbf06b 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Typespec do alias Lexical.Ast.Env - alias Lexical.RemoteControl.Completion.Candidate + alias Engine.Completion.Candidate alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations.Callable diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex index 19d1b438..ce3323ab 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Variable do alias Lexical.Ast.Env - alias Lexical.RemoteControl.Completion.Candidate + alias Engine.Completion.Candidate alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable diff --git a/expert/lib/lexical/server/iex/helpers.ex b/expert/lib/lexical/server/iex/helpers.ex index 01fe32aa..fc054e18 100644 --- a/expert/lib/lexical/server/iex/helpers.ex +++ b/expert/lib/lexical/server/iex/helpers.ex @@ -1,23 +1,23 @@ defmodule Expert.IEx.Helpers do alias Lexical.Ast - alias Lexical.Document - alias Lexical.Document.Position + alias Forge.Document + alias Forge.Document.Position alias Lexical.Project alias Lexical.Protocol.Types.Completion - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Search + alias Engine + alias Engine.Search alias Expert.CodeIntelligence defmacro __using__(_) do quote do - alias Lexical.Document - alias Lexical.Document.Position - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Search + alias Forge.Document + alias Forge.Document.Position + alias Engine + alias Engine.Search import unquote(__MODULE__) - RemoteControl.Module.Loader.start_link(nil) - RemoteControl.Dispatch.start_link([]) + Engine.Module.Loader.start_link(nil) + Engine.Dispatch.start_link([]) end end @@ -29,7 +29,7 @@ defmodule Expert.IEx.Helpers do def observer(project) do project |> ensure_project() - |> RemoteControl.call(:observer, :start) + |> Engine.call(:observer, :start) end def doc(text) do @@ -56,7 +56,7 @@ defmodule Expert.IEx.Helpers do def search_store(project) do project = ensure_project(project) - RemoteControl.set_project(project) + Engine.set_project(project) Search.Store.start_link( project, @@ -82,7 +82,7 @@ defmodule Expert.IEx.Helpers do def compile_project(project) do project |> ensure_project() - |> RemoteControl.Api.schedule_compile(true) + |> Engine.Api.schedule_compile(true) end def compile_file(project, source) when is_binary(source) do @@ -94,7 +94,7 @@ defmodule Expert.IEx.Helpers do def compile_file(project, %Document{} = document) do project |> ensure_project() - |> RemoteControl.Api.compile_document(document) + |> Engine.Api.compile_document(document) end def complete(project, source, context \\ nil) diff --git a/expert/lib/lexical/server/project/diagnostics.ex b/expert/lib/lexical/server/project/diagnostics.ex index b2261f53..da0ac88a 100644 --- a/expert/lib/lexical/server/project/diagnostics.ex +++ b/expert/lib/lexical/server/project/diagnostics.ex @@ -2,12 +2,12 @@ defmodule Expert.Project.Diagnostics do alias Lexical.Formats alias Lexical.Project alias Lexical.Protocol.Notifications.PublishDiagnostics - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Api.Messages + alias Engine + alias Forge.Api.Messages alias Expert.Project.Diagnostics.State alias Expert.Transport - import Messages + import Forge.Api.Messages require Logger use GenServer @@ -26,7 +26,7 @@ defmodule Expert.Project.Diagnostics do @impl GenServer def init([%Project{} = project]) do - RemoteControl.Api.register_listener(project, self(), [ + Engine.Api.register_listener(project, self(), [ file_diagnostics(), project_compile_requested(), project_compiled(), diff --git a/expert/lib/lexical/server/project/diagnostics/state.ex b/expert/lib/lexical/server/project/diagnostics/state.ex index 8028412a..786c5fb0 100644 --- a/expert/lib/lexical/server/project/diagnostics/state.ex +++ b/expert/lib/lexical/server/project/diagnostics/state.ex @@ -28,7 +28,7 @@ defmodule Expert.Project.Diagnostics.State do end end - alias Lexical.Document + alias Forge.Document alias Lexical.Plugin.V1.Diagnostic alias Lexical.Project diff --git a/expert/lib/lexical/server/project/intelligence.ex b/expert/lib/lexical/server/project/intelligence.ex index 750bd4c6..a9e3656e 100644 --- a/expert/lib/lexical/server/project/intelligence.ex +++ b/expert/lib/lexical/server/project/intelligence.ex @@ -59,10 +59,10 @@ defmodule Expert.Project.Intelligence do end alias Lexical.Project - alias Lexical.RemoteControl.Api + alias Expert.Api use GenServer - import Api.Messages + import Forge.Api.Messages @generations [ :self, diff --git a/expert/lib/lexical/server/project/node.ex b/expert/lib/lexical/server/project/node.ex index 222cf4bc..89dc8ba4 100644 --- a/expert/lib/lexical/server/project/node.ex +++ b/expert/lib/lexical/server/project/node.ex @@ -12,7 +12,7 @@ defmodule Expert.Project.Node do end alias Lexical.Project - alias Lexical.RemoteControl + alias Engine alias Expert.Project.Progress require Logger @@ -60,7 +60,7 @@ defmodule Expert.Project.Node do @impl GenServer def handle_continue(:trigger_build, %State{} = state) do - RemoteControl.Api.schedule_compile(state.project, true) + Engine.Api.schedule_compile(state.project, true) {:noreply, state} end @@ -71,7 +71,7 @@ defmodule Expert.Project.Node do @impl GenServer def handle_cast(:trigger_build, %State{} = state) do - RemoteControl.Api.schedule_compile(state.project, true) + Engine.Api.schedule_compile(state.project, true) {:noreply, state} end @@ -91,14 +91,14 @@ defmodule Expert.Project.Node do # private api def start_node(%Project{} = project) do - with {:ok, node, node_pid} <- RemoteControl.start_link(project) do + with {:ok, node, node_pid} <- Engine.start_link(project) do Node.monitor(node, true) {:ok, State.new(project, node, node_pid)} end end defp delete_build_artifacts(%Project{} = project) do - build_path = RemoteControl.Build.path(project) + build_path = Engine.Build.path(project) case File.rm_rf(build_path) do {:ok, _deleted} -> :ok diff --git a/expert/lib/lexical/server/project/progress.ex b/expert/lib/lexical/server/project/progress.ex index b812b126..9659cbeb 100644 --- a/expert/lib/lexical/server/project/progress.ex +++ b/expert/lib/lexical/server/project/progress.ex @@ -2,7 +2,7 @@ defmodule Expert.Project.Progress do alias Lexical.Project alias Expert.Project.Progress.State - import Lexical.RemoteControl.Api.Messages + import Forge.Api.Messages use GenServer diff --git a/expert/lib/lexical/server/project/progress/state.ex b/expert/lib/lexical/server/project/progress/state.ex index 9b88b3dc..ddd0077b 100644 --- a/expert/lib/lexical/server/project/progress/state.ex +++ b/expert/lib/lexical/server/project/progress/state.ex @@ -7,7 +7,7 @@ defmodule Expert.Project.Progress.State do alias Expert.Project.Progress.Value alias Expert.Transport - import Lexical.RemoteControl.Api.Messages + import Forge.Api.Messages defstruct project: nil, progress_by_label: %{} diff --git a/expert/lib/lexical/server/project/progress/support.ex b/expert/lib/lexical/server/project/progress/support.ex index e044954a..59195db2 100644 --- a/expert/lib/lexical/server/project/progress/support.ex +++ b/expert/lib/lexical/server/project/progress/support.ex @@ -2,7 +2,7 @@ defmodule Expert.Project.Progress.Support do alias Lexical.Project alias Expert.Project.Progress - import Lexical.RemoteControl.Api.Messages + import Forge.Api.Messages defmacro __using__(_) do quote do diff --git a/expert/lib/lexical/server/project/search_listener.ex b/expert/lib/lexical/server/project/search_listener.ex index 69cf53c9..f75cba25 100644 --- a/expert/lib/lexical/server/project/search_listener.ex +++ b/expert/lib/lexical/server/project/search_listener.ex @@ -3,11 +3,11 @@ defmodule Expert.Project.SearchListener do alias Lexical.Project alias Lexical.Protocol.Id alias Lexical.Protocol.Requests - alias Lexical.RemoteControl.Api + alias Expert.Api alias Expert alias Expert.Window - import Api.Messages + import Forge.Api.Messages use GenServer require Logger diff --git a/expert/lib/lexical/server/project/supervisor.ex b/expert/lib/lexical/server/project/supervisor.ex index ed26ae23..f62fe87a 100644 --- a/expert/lib/lexical/server/project/supervisor.ex +++ b/expert/lib/lexical/server/project/supervisor.ex @@ -1,6 +1,6 @@ defmodule Expert.Project.Supervisor do alias Lexical.Project - alias Lexical.RemoteControl.ProjectNodeSupervisor + alias Engine.ProjectNodeSupervisor alias Expert.Project.Diagnostics alias Expert.Project.Intelligence alias Expert.Project.Node diff --git a/expert/lib/lexical/server/provider/handlers/code_action.ex b/expert/lib/lexical/server/provider/handlers/code_action.ex index 4e35828a..4f54598c 100644 --- a/expert/lib/lexical/server/provider/handlers/code_action.ex +++ b/expert/lib/lexical/server/provider/handlers/code_action.ex @@ -3,8 +3,8 @@ defmodule Expert.Provider.Handlers.CodeAction do alias Lexical.Protocol.Responses alias Lexical.Protocol.Types alias Lexical.Protocol.Types.Workspace - alias Lexical.RemoteControl - alias Lexical.RemoteControl.CodeAction + alias Engine + alias Engine.CodeAction alias Expert.Configuration require Logger @@ -13,7 +13,7 @@ defmodule Expert.Provider.Handlers.CodeAction do diagnostics = Enum.map(request.context.diagnostics, &to_code_action_diagnostic/1) code_actions = - RemoteControl.Api.code_actions( + Engine.Api.code_actions( config.project, request.document, request.range, diff --git a/expert/lib/lexical/server/provider/handlers/code_lens.ex b/expert/lib/lexical/server/provider/handlers/code_lens.ex index 7324f11d..879e89f3 100644 --- a/expert/lib/lexical/server/provider/handlers/code_lens.ex +++ b/expert/lib/lexical/server/provider/handlers/code_lens.ex @@ -1,12 +1,12 @@ defmodule Expert.Provider.Handlers.CodeLens do - alias Lexical.Document - alias Lexical.Document.Position - alias Lexical.Document.Range + alias Forge.Document + alias Forge.Document.Position + alias Forge.Document.Range alias Lexical.Project alias Lexical.Protocol.Requests alias Lexical.Protocol.Responses alias Lexical.Protocol.Types.CodeLens - alias Lexical.RemoteControl + alias Engine alias Expert.Configuration alias Expert.Provider.Handlers @@ -53,6 +53,6 @@ defmodule Expert.Provider.Handlers.CodeLens do document_path = Path.expand(document.path) document_path == Project.mix_exs_path(project) and - not RemoteControl.Api.index_running?(project) + not Engine.Api.index_running?(project) end end diff --git a/expert/lib/lexical/server/provider/handlers/commands.ex b/expert/lib/lexical/server/provider/handlers/commands.ex index a7e2bfe7..e17cbda8 100644 --- a/expert/lib/lexical/server/provider/handlers/commands.ex +++ b/expert/lib/lexical/server/provider/handlers/commands.ex @@ -4,7 +4,7 @@ defmodule Expert.Provider.Handlers.Commands do alias Lexical.Protocol.Responses alias Lexical.Protocol.Types alias Lexical.Protocol.Types.ErrorCodes - alias Lexical.RemoteControl + alias Engine alias Expert.Configuration alias Expert.Window @@ -42,7 +42,7 @@ defmodule Expert.Provider.Handlers.Commands do end defp reindex(%Project{} = project, request_id) do - case RemoteControl.Api.reindex(project) do + case Engine.Api.reindex(project) do :ok -> Responses.ExecuteCommand.new(request_id, "ok") diff --git a/expert/lib/lexical/server/provider/handlers/completion.ex b/expert/lib/lexical/server/provider/handlers/completion.ex index 0881cc43..aa55ad6b 100644 --- a/expert/lib/lexical/server/provider/handlers/completion.ex +++ b/expert/lib/lexical/server/provider/handlers/completion.ex @@ -1,7 +1,7 @@ defmodule Expert.Provider.Handlers.Completion do alias Lexical.Ast - alias Lexical.Document - alias Lexical.Document.Position + alias Forge.Document + alias Forge.Document.Position alias Lexical.Protocol.Requests alias Lexical.Protocol.Responses alias Lexical.Protocol.Types.Completion diff --git a/expert/lib/lexical/server/provider/handlers/document_symbols.ex b/expert/lib/lexical/server/provider/handlers/document_symbols.ex index 0b47bdb5..0d64b786 100644 --- a/expert/lib/lexical/server/provider/handlers/document_symbols.ex +++ b/expert/lib/lexical/server/provider/handlers/document_symbols.ex @@ -1,11 +1,11 @@ defmodule Expert.Provider.Handlers.DocumentSymbols do - alias Lexical.Document + alias Forge.Document alias Lexical.Protocol.Requests.DocumentSymbols alias Lexical.Protocol.Responses alias Lexical.Protocol.Types.Document.Symbol alias Lexical.Protocol.Types.Symbol.Kind, as: SymbolKind - alias Lexical.RemoteControl.Api - alias Lexical.RemoteControl.CodeIntelligence.Symbols + alias Engine.Api + alias Engine.CodeIntelligence.Symbols alias Expert.Configuration require SymbolKind diff --git a/expert/lib/lexical/server/provider/handlers/find_references.ex b/expert/lib/lexical/server/provider/handlers/find_references.ex index d5fa1eda..d030e6c7 100644 --- a/expert/lib/lexical/server/provider/handlers/find_references.ex +++ b/expert/lib/lexical/server/provider/handlers/find_references.ex @@ -1,9 +1,9 @@ defmodule Expert.Provider.Handlers.FindReferences do alias Lexical.Ast - alias Lexical.Document + alias Forge.Document alias Lexical.Protocol.Requests.FindReferences alias Lexical.Protocol.Responses - alias Lexical.RemoteControl.Api + alias Engine.Api alias Expert.Configuration require Logger diff --git a/expert/lib/lexical/server/provider/handlers/formatting.ex b/expert/lib/lexical/server/provider/handlers/formatting.ex index d18f2995..03710679 100644 --- a/expert/lib/lexical/server/provider/handlers/formatting.ex +++ b/expert/lib/lexical/server/provider/handlers/formatting.ex @@ -1,8 +1,8 @@ defmodule Expert.Provider.Handlers.Formatting do - alias Lexical.Document.Changes + alias Forge.Document.Changes alias Lexical.Protocol.Requests alias Lexical.Protocol.Responses - alias Lexical.RemoteControl + alias Engine alias Expert.Configuration require Logger @@ -10,7 +10,7 @@ defmodule Expert.Provider.Handlers.Formatting do def handle(%Requests.Formatting{} = request, %Configuration{} = config) do document = request.document - case RemoteControl.Api.format(config.project, document) do + case Engine.Api.format(config.project, document) do {:ok, %Changes{} = document_edits} -> response = Responses.Formatting.new(request.id, document_edits) Logger.info("Response #{inspect(response)}") diff --git a/expert/lib/lexical/server/provider/handlers/go_to_definition.ex b/expert/lib/lexical/server/provider/handlers/go_to_definition.ex index 5f83da86..b90cb67d 100644 --- a/expert/lib/lexical/server/provider/handlers/go_to_definition.ex +++ b/expert/lib/lexical/server/provider/handlers/go_to_definition.ex @@ -1,13 +1,13 @@ defmodule Expert.Provider.Handlers.GoToDefinition do alias Lexical.Protocol.Requests.GoToDefinition alias Lexical.Protocol.Responses - alias Lexical.RemoteControl + alias Engine alias Expert.Configuration require Logger def handle(%GoToDefinition{} = request, %Configuration{} = config) do - case RemoteControl.Api.definition(config.project, request.document, request.position) do + case Engine.Api.definition(config.project, request.document, request.position) do {:ok, native_location} -> {:reply, Responses.GoToDefinition.new(request.id, native_location)} diff --git a/expert/lib/lexical/server/provider/handlers/hover.ex b/expert/lib/lexical/server/provider/handlers/hover.ex index 1368ce34..a5de7ddf 100644 --- a/expert/lib/lexical/server/provider/handlers/hover.ex +++ b/expert/lib/lexical/server/provider/handlers/hover.ex @@ -1,14 +1,14 @@ defmodule Expert.Provider.Handlers.Hover do alias Lexical.Ast alias Lexical.Ast.Analysis - alias Lexical.Document - alias Lexical.Document.Position + alias Forge.Document + alias Forge.Document.Position alias Lexical.Project alias Lexical.Protocol.Requests alias Lexical.Protocol.Responses alias Lexical.Protocol.Types.Hover - alias Lexical.RemoteControl - alias Lexical.RemoteControl.CodeIntelligence.Docs + alias Engine + alias Engine.CodeIntelligence.Docs alias Expert.Configuration alias Expert.Provider.Markdown @@ -32,11 +32,11 @@ defmodule Expert.Provider.Handlers.Hover do end defp resolve_entity(%Project{} = project, %Analysis{} = analysis, %Position{} = position) do - RemoteControl.Api.resolve_entity(project, analysis, position) + Engine.Api.resolve_entity(project, analysis, position) end defp hover_content({kind, module}, %Project{} = project) when kind in [:module, :struct] do - case RemoteControl.Api.docs(project, module, exclude_hidden: false) do + case Engine.Api.docs(project, module, exclude_hidden: false) do {:ok, %Docs{} = module_docs} -> header = module_header(kind, module_docs) types = module_header_types(kind, module_docs) @@ -59,7 +59,7 @@ defmodule Expert.Provider.Handlers.Hover do end defp hover_content({:call, module, fun, arity}, %Project{} = project) do - with {:ok, %Docs{} = module_docs} <- RemoteControl.Api.docs(project, module), + with {:ok, %Docs{} = module_docs} <- Engine.Api.docs(project, module), {:ok, entries} <- Map.fetch(module_docs.functions_and_macros, fun) do sections = entries @@ -72,7 +72,7 @@ defmodule Expert.Provider.Handlers.Hover do end defp hover_content({:type, module, type, arity}, %Project{} = project) do - with {:ok, %Docs{} = module_docs} <- RemoteControl.Api.docs(project, module), + with {:ok, %Docs{} = module_docs} <- Engine.Api.docs(project, module), {:ok, entries} <- Map.fetch(module_docs.types, type) do case Enum.find(entries, &(&1.arity == arity)) do %Docs.Entry{} = entry -> diff --git a/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex b/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex index 7ad78bde..dd1d181d 100644 --- a/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex +++ b/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex @@ -4,8 +4,8 @@ defmodule Expert.Provider.Handlers.WorkspaceSymbol do alias Lexical.Protocol.Types.Location alias Lexical.Protocol.Types.Symbol.Kind, as: SymbolKind alias Lexical.Protocol.Types.Workspace.Symbol - alias Lexical.RemoteControl.Api - alias Lexical.RemoteControl.CodeIntelligence.Symbols + alias Engine.Api + alias Engine.CodeIntelligence.Symbols alias Expert.Configuration require SymbolKind diff --git a/expert/lib/lexical/server/state.ex b/expert/lib/lexical/server/state.ex index c99a49be..8311d3b7 100644 --- a/expert/lib/lexical/server/state.ex +++ b/expert/lib/lexical/server/state.ex @@ -1,5 +1,5 @@ defmodule Expert.State do - alias Lexical.Document + alias Forge.Document alias Lexical.Protocol.Id alias Lexical.Protocol.Notifications alias Lexical.Protocol.Notifications.DidChange @@ -23,8 +23,8 @@ defmodule Expert.State do alias Lexical.Protocol.Types.FileSystemWatcher alias Lexical.Protocol.Types.Registration alias Lexical.Protocol.Types.TextDocument - alias Lexical.RemoteControl - alias Lexical.RemoteControl.Api + alias Engine + alias Engine.Api alias Expert.CodeIntelligence alias Expert.Configuration alias Expert.Project @@ -236,7 +236,7 @@ defmodule Expert.State do Enum.each(event.changes, fn %FileEvent{} = change -> event = filesystem_event(project: Project, uri: change.uri, event_type: change.type) - RemoteControl.Api.broadcast(project, event) + Engine.Api.broadcast(project, event) end) {:ok, state} diff --git a/expert/lib/lexical/server/transport.ex b/expert/lib/lexical/server/transport.ex deleted file mode 100644 index 274715ee..00000000 --- a/expert/lib/lexical/server/transport.ex +++ /dev/null @@ -1,12 +0,0 @@ -defmodule Expert.Transport do - @moduledoc """ - A behaviour for a LSP transport - """ - @callback write(Jason.Encoder.t()) :: Jason.Encoder.t() - - alias Expert.Transport.StdIO - - @implementation Application.compile_env(:server, :transport, StdIO) - - defdelegate write(message), to: @implementation -end diff --git a/expert/lib/lexical/server/transport/std_io.ex b/expert/lib/lexical/server/transport/std_io.ex deleted file mode 100644 index 6fc0bc2e..00000000 --- a/expert/lib/lexical/server/transport/std_io.ex +++ /dev/null @@ -1,145 +0,0 @@ -defmodule Expert.Transport.StdIO do - alias Lexical.Protocol.JsonRpc - - require Logger - - @behaviour Expert.Transport - - def start_link(device, callback) do - pid = :proc_lib.spawn_link(__MODULE__, :init, [{callback, device}]) - {:ok, pid} - end - - def child_spec([device, callback]) do - %{id: __MODULE__, start: {__MODULE__, :start_link, [device, callback]}} - end - - def init({callback, device}) do - :io.setopts(binary: true, encoding: :latin1) - loop([], device, callback) - end - - def write(io_device \\ :stdio, payload) - - def write(io_device, %_{} = payload) do - with {:ok, lsp} <- Lexical.Proto.Convert.to_lsp(payload), - {:ok, json} <- Jason.encode(lsp) do - write(io_device, json) - end - end - - def write(io_device, %{} = payload) do - with {:ok, encoded} <- Jason.encode(payload) do - write(io_device, encoded) - end - end - - def write(io_device, payload) when is_binary(payload) do - message = - case io_device do - device when device in [:stdio, :standard_io] or is_pid(device) -> - {:ok, json_rpc} = JsonRpc.encode(payload) - json_rpc - - _ -> - payload - end - - IO.binwrite(io_device, message) - end - - def write(_, nil) do - end - - def write(_, []) do - end - - # private - - defp loop(buffer, device, callback) do - case IO.binread(device, :line) do - "\n" -> - headers = parse_headers(buffer) - - with {:ok, content_length} <- content_length(headers), - {:ok, data} <- read_body(device, content_length), - {:ok, message} <- JsonRpc.decode(data) do - callback.(message) - else - {:error, :empty_response} -> - :noop - - {:error, reason} -> - Logger.critical("read protocol message: #{inspect(reason)}") - end - - loop([], device, callback) - - :eof -> - Logger.critical("stdio received :eof, server will stop.") - maybe_stop() - - line -> - loop([line | buffer], device, callback) - end - end - - defp content_length(headers) do - with {:ok, len_str} <- find_header(headers, "content-length") do - parse_length(len_str) - end - end - - defp find_header(headers, name) do - case List.keyfind(headers, name, 0) do - {_, len_str} -> {:ok, len_str} - nil -> {:error, {:header_not_found, name}} - end - end - - defp parse_length(len_str) when is_binary(len_str) do - case Integer.parse(len_str) do - {int, ""} -> {:ok, int} - :error -> {:error, {:cant_parse_length, len_str}} - end - end - - defp read_body(device, byte_count) do - case IO.binread(device, byte_count) do - data when is_binary(data) -> - {:ok, data} - - :eof -> - Logger.critical("stdio received :eof, server will stop.") - maybe_stop() - - {:error, reason} -> - {:error, reason} - end - end - - defp parse_headers(headers) do - Enum.map(headers, &parse_header/1) - end - - defp parse_header(line) do - [name, value] = String.split(line, ":") - - header_name = - name - |> String.downcase() - |> String.trim() - - {header_name, String.trim(value)} - end - - if Mix.env() == :test do - defp maybe_stop do - :ok - end - else - defp maybe_stop do - System.stop() - end - end -end diff --git a/expert/lib/lexical/server/window.ex b/expert/lib/lexical/server/window.ex deleted file mode 100644 index 6247b374..00000000 --- a/expert/lib/lexical/server/window.ex +++ /dev/null @@ -1,89 +0,0 @@ -defmodule Expert.Window do - alias Lexical.Protocol.Id - alias Lexical.Protocol.Notifications.LogMessage - alias Lexical.Protocol.Notifications.ShowMessage - alias Lexical.Protocol.Requests - alias Lexical.Protocol.Types - alias Expert.Transport - - @type level :: :error | :warning | :info | :log - @type message_result :: {:errory, term()} | {:ok, nil} | {:ok, Types.Message.ActionItem.t()} - @type on_response_callback :: (message_result() -> any()) - @type message :: String.t() - @type action :: String.t() - - @levels [:error, :warning, :info, :log] - - @spec log(level, message()) :: :ok - def log(level, message) when level in @levels and is_binary(message) do - log_message = apply(LogMessage, level, [message]) - Transport.write(log_message) - :ok - end - - for level <- [:error, :warning, :info] do - def unquote(level)(message) do - log(unquote(level), message) - end - end - - @spec show(level(), message()) :: :ok - def show(level, message) when level in @levels and is_binary(message) do - show_message = apply(ShowMessage, level, [message]) - Transport.write(show_message) - :ok - end - - @spec show_message(level(), message()) :: :ok - def show_message(level, message) do - request = Requests.ShowMessageRequest.new(id: Id.next(), message: message, type: level) - Expert.server_request(request) - end - - for level <- @levels, - fn_name = :"show_#{level}_message" do - def unquote(fn_name)(message) do - show_message(unquote(level), message) - end - end - - for level <- @levels, - fn_name = :"show_#{level}_message" do - @doc """ - Shows a message at the #{level} level. Delegates to `show_message/4` - """ - def unquote(fn_name)(message, actions, on_response) when is_function(on_response, 1) do - show_message(unquote(level), message, actions, on_response) - end - end - - @doc """ - Shows a message request and handles the response - - Displays a message to the user in the UI and waits for a response. - The result type handed to the callback function is a - `Lexical.Protocol.Types.Message.ActionItem` or nil if there was no response - from the user. - - The strings passed in as the `actions` command are displayed to the user, and when - they select one, the `Types.Message.ActionItem` is passed to the callback function. - """ - @spec show_message(level(), message(), [action()], on_response_callback) :: :ok - def show_message(level, message, actions, on_response) - when is_function(on_response, 1) do - action_items = - Enum.map(actions, fn action_string -> - Types.Message.ActionItem.new(title: action_string) - end) - - request = - Requests.ShowMessageRequest.new( - id: Id.next(), - message: message, - actions: action_items, - type: level - ) - - Expert.server_request(request, fn _request, response -> on_response.(response) end) - end -end diff --git a/expert/mix.exs b/expert/mix.exs index feeb947a..bd24ce74 100644 --- a/expert/mix.exs +++ b/expert/mix.exs @@ -50,6 +50,7 @@ defmodule Expert.MixProject do github: "elixir-tools/gen_lsp", branch: "change-schematic-function", override: true}, # {:gen_lsp, "~> 0.10"}, {:burrito, "~> 1.0", only: [:dev, :prod]}, + {:forge, path: "../forge"}, {:namespace, path: "../namespace"} ] end diff --git a/expert/mix.lock b/expert/mix.lock index ceab83ed..121b2596 100644 --- a/expert/mix.lock +++ b/expert/mix.lock @@ -10,6 +10,8 @@ "nimble_pool": {:hex, :nimble_pool, "1.1.0", "bf9c29fbdcba3564a8b800d1eeb5a3c58f36e1e11d7b7fb2e084a643f645f06b", [:mix], [], "hexpm", "af2e4e6b34197db81f7aad230c1118eac993acc0dae6bc83bac0126d4ae0813a"}, "req": {:hex, :req, "0.5.6", "8fe1eead4a085510fe3d51ad854ca8f20a622aae46e97b302f499dfb84f726ac", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.17", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "cfaa8e720945d46654853de39d368f40362c2641c4b2153c886418914b372185"}, "schematic": {:hex, :schematic, "0.2.1", "0b091df94146fd15a0a343d1bd179a6c5a58562527746dadd09477311698dbb1", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "0b255d65921e38006138201cd4263fd8bb807d9dfc511074615cd264a571b3b1"}, + "snowflake": {:hex, :snowflake, "1.0.4", "8433b4e04fbed19272c55e1b7de0f7a1ee1230b3ae31a813b616fd6ef279e87a", [:mix], [], "hexpm", "badb07ebb089a5cff737738297513db3962760b10fe2b158ae3bebf0b4d5be13"}, + "sourceror": {:hex, :sourceror, "1.7.1", "599d78f4cc2be7d55c9c4fd0a8d772fd0478e3a50e726697c20d13d02aa056d4", [:mix], [], "hexpm", "cd6f268fe29fa00afbc535e215158680a0662b357dc784646d7dff28ac65a0fc"}, "telemetry": {:hex, :telemetry, "1.3.0", "fedebbae410d715cf8e7062c96a1ef32ec22e764197f70cda73d82778d61e7a2", [:rebar3], [], "hexpm", "7015fc8919dbe63764f4b4b87a95b7c0996bd539e0d499be6ec9d7f3875b79e6"}, "typed_struct": {:hex, :typed_struct, "0.3.0", "939789e3c1dca39d7170c87f729127469d1315dcf99fee8e152bb774b17e7ff7", [:mix], [], "hexpm", "c50bd5c3a61fe4e198a8504f939be3d3c85903b382bde4865579bc23111d1b6d"}, } diff --git a/engine/lib/engine/api/messages.ex b/forge/lib/forge/api/messages.ex similarity index 99% rename from engine/lib/engine/api/messages.ex rename to forge/lib/forge/api/messages.ex index 49afdada..eea276da 100644 --- a/engine/lib/engine/api/messages.ex +++ b/forge/lib/forge/api/messages.ex @@ -1,4 +1,4 @@ -defmodule Engine.Api.Messages do +defmodule Forge.Api.Messages do alias Forge.Project import Record From 2e6f79f361040734f0809d080367300c44bd4d13 Mon Sep 17 00:00:00 2001 From: Mitchell Hanberg Date: Sun, 5 Jan 2025 17:20:47 -0500 Subject: [PATCH 10/12] wip: rename Lexical.Project to Forge.Project in more places --- .../completion/translations/module_or_behaviour.ex | 2 +- expert/lib/lexical/server/configuration.ex | 2 +- expert/lib/lexical/server/iex/helpers.ex | 10 +++++----- expert/lib/lexical/server/project/diagnostics.ex | 2 +- expert/lib/lexical/server/project/diagnostics/state.ex | 2 +- expert/lib/lexical/server/project/intelligence.ex | 4 ++-- expert/lib/lexical/server/project/node.ex | 2 +- expert/lib/lexical/server/project/progress.ex | 2 +- expert/lib/lexical/server/project/progress/state.ex | 2 +- expert/lib/lexical/server/project/progress/support.ex | 2 +- expert/lib/lexical/server/project/search_listener.ex | 2 +- expert/lib/lexical/server/project/supervisor.ex | 2 +- .../lib/lexical/server/provider/handlers/code_lens.ex | 2 +- .../lib/lexical/server/provider/handlers/commands.ex | 2 +- expert/lib/lexical/server/provider/handlers/hover.ex | 2 +- 15 files changed, 20 insertions(+), 20 deletions(-) diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex index 6ea79f86..d051c11a 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex @@ -139,7 +139,7 @@ defmodule Expert.CodeIntelligence.Completion.Translations.ModuleOrBehaviour do defp strip_leading_period(<<".", rest::binary>>), do: rest defp strip_leading_period(string_without_period), do: string_without_period - defp immediate_descendent_struct_modules(%Lexical.Project{} = project, module_name) do + defp immediate_descendent_struct_modules(%Forge.Project{} = project, module_name) do Intelligence.collect_struct_modules(project, module_name, to: :grandchild) end end diff --git a/expert/lib/lexical/server/configuration.ex b/expert/lib/lexical/server/configuration.ex index c568e247..1d675bbb 100644 --- a/expert/lib/lexical/server/configuration.ex +++ b/expert/lib/lexical/server/configuration.ex @@ -3,7 +3,7 @@ defmodule Expert.Configuration do Encapsulates server configuration options and client capability support. """ - alias Lexical.Project + alias Forge.Project alias Lexical.Protocol.Id alias Lexical.Protocol.Notifications.DidChangeConfiguration alias Lexical.Protocol.Requests diff --git a/expert/lib/lexical/server/iex/helpers.ex b/expert/lib/lexical/server/iex/helpers.ex index fc054e18..93ac79f9 100644 --- a/expert/lib/lexical/server/iex/helpers.ex +++ b/expert/lib/lexical/server/iex/helpers.ex @@ -2,7 +2,7 @@ defmodule Expert.IEx.Helpers do alias Lexical.Ast alias Forge.Document alias Forge.Document.Position - alias Lexical.Project + alias Forge.Project alias Lexical.Protocol.Types.Completion alias Engine alias Engine.Search @@ -142,19 +142,19 @@ defmodule Expert.IEx.Helpers do ## Examples iex> project() - %Lexical.Project{ + %Forge.Project{ root_uri: "file:///.../lexical ... } iex> project(:my_project) - %Lexical.Project{ + %Forge.Project{ root_uri: "file:///.../my_project" ... } iex> project(:navigations, fixture: true) - %Lexical.Project{ + %Forge.Project{ root_uri: "file:///.../lexical/apps/remote_control/test/fixtures/navigations" ... } @@ -177,7 +177,7 @@ defmodule Expert.IEx.Helpers do |> Path.expand() project_uri = "file://#{project_path}" - Lexical.Project.new(project_uri) + Forge.Project.new(project_uri) end) end diff --git a/expert/lib/lexical/server/project/diagnostics.ex b/expert/lib/lexical/server/project/diagnostics.ex index da0ac88a..1f33956d 100644 --- a/expert/lib/lexical/server/project/diagnostics.ex +++ b/expert/lib/lexical/server/project/diagnostics.ex @@ -1,6 +1,6 @@ defmodule Expert.Project.Diagnostics do alias Lexical.Formats - alias Lexical.Project + alias Forge.Project alias Lexical.Protocol.Notifications.PublishDiagnostics alias Engine alias Forge.Api.Messages diff --git a/expert/lib/lexical/server/project/diagnostics/state.ex b/expert/lib/lexical/server/project/diagnostics/state.ex index 786c5fb0..2bcd93a5 100644 --- a/expert/lib/lexical/server/project/diagnostics/state.ex +++ b/expert/lib/lexical/server/project/diagnostics/state.ex @@ -30,7 +30,7 @@ defmodule Expert.Project.Diagnostics.State do alias Forge.Document alias Lexical.Plugin.V1.Diagnostic - alias Lexical.Project + alias Forge.Project defstruct project: nil, entries_by_uri: %{} diff --git a/expert/lib/lexical/server/project/intelligence.ex b/expert/lib/lexical/server/project/intelligence.ex index a9e3656e..3bc8a977 100644 --- a/expert/lib/lexical/server/project/intelligence.ex +++ b/expert/lib/lexical/server/project/intelligence.ex @@ -1,7 +1,7 @@ defmodule Expert.Project.Intelligence do defmodule State do alias Lexical.Formats - alias Lexical.Project + alias Forge.Project defstruct project: nil, struct_modules: MapSet.new() @@ -58,7 +58,7 @@ defmodule Expert.Project.Intelligence do end end - alias Lexical.Project + alias Forge.Project alias Expert.Api use GenServer diff --git a/expert/lib/lexical/server/project/node.ex b/expert/lib/lexical/server/project/node.ex index 89dc8ba4..50825a85 100644 --- a/expert/lib/lexical/server/project/node.ex +++ b/expert/lib/lexical/server/project/node.ex @@ -11,7 +11,7 @@ defmodule Expert.Project.Node do end end - alias Lexical.Project + alias Forge.Project alias Engine alias Expert.Project.Progress diff --git a/expert/lib/lexical/server/project/progress.ex b/expert/lib/lexical/server/project/progress.ex index 9659cbeb..5ec91eb8 100644 --- a/expert/lib/lexical/server/project/progress.ex +++ b/expert/lib/lexical/server/project/progress.ex @@ -1,5 +1,5 @@ defmodule Expert.Project.Progress do - alias Lexical.Project + alias Forge.Project alias Expert.Project.Progress.State import Forge.Api.Messages diff --git a/expert/lib/lexical/server/project/progress/state.ex b/expert/lib/lexical/server/project/progress/state.ex index ddd0077b..82c87ec8 100644 --- a/expert/lib/lexical/server/project/progress/state.ex +++ b/expert/lib/lexical/server/project/progress/state.ex @@ -1,5 +1,5 @@ defmodule Expert.Project.Progress.State do - alias Lexical.Project + alias Forge.Project alias Lexical.Protocol.Id alias Lexical.Protocol.Requests alias Expert.Configuration diff --git a/expert/lib/lexical/server/project/progress/support.ex b/expert/lib/lexical/server/project/progress/support.ex index 59195db2..29f11a65 100644 --- a/expert/lib/lexical/server/project/progress/support.ex +++ b/expert/lib/lexical/server/project/progress/support.ex @@ -1,5 +1,5 @@ defmodule Expert.Project.Progress.Support do - alias Lexical.Project + alias Forge.Project alias Expert.Project.Progress import Forge.Api.Messages diff --git a/expert/lib/lexical/server/project/search_listener.ex b/expert/lib/lexical/server/project/search_listener.ex index f75cba25..7b006384 100644 --- a/expert/lib/lexical/server/project/search_listener.ex +++ b/expert/lib/lexical/server/project/search_listener.ex @@ -1,6 +1,6 @@ defmodule Expert.Project.SearchListener do alias Lexical.Formats - alias Lexical.Project + alias Forge.Project alias Lexical.Protocol.Id alias Lexical.Protocol.Requests alias Expert.Api diff --git a/expert/lib/lexical/server/project/supervisor.ex b/expert/lib/lexical/server/project/supervisor.ex index f62fe87a..6490c0f9 100644 --- a/expert/lib/lexical/server/project/supervisor.ex +++ b/expert/lib/lexical/server/project/supervisor.ex @@ -1,5 +1,5 @@ defmodule Expert.Project.Supervisor do - alias Lexical.Project + alias Forge.Project alias Engine.ProjectNodeSupervisor alias Expert.Project.Diagnostics alias Expert.Project.Intelligence diff --git a/expert/lib/lexical/server/provider/handlers/code_lens.ex b/expert/lib/lexical/server/provider/handlers/code_lens.ex index 879e89f3..c6114951 100644 --- a/expert/lib/lexical/server/provider/handlers/code_lens.ex +++ b/expert/lib/lexical/server/provider/handlers/code_lens.ex @@ -2,7 +2,7 @@ defmodule Expert.Provider.Handlers.CodeLens do alias Forge.Document alias Forge.Document.Position alias Forge.Document.Range - alias Lexical.Project + alias Forge.Project alias Lexical.Protocol.Requests alias Lexical.Protocol.Responses alias Lexical.Protocol.Types.CodeLens diff --git a/expert/lib/lexical/server/provider/handlers/commands.ex b/expert/lib/lexical/server/provider/handlers/commands.ex index e17cbda8..49b957c0 100644 --- a/expert/lib/lexical/server/provider/handlers/commands.ex +++ b/expert/lib/lexical/server/provider/handlers/commands.ex @@ -1,5 +1,5 @@ defmodule Expert.Provider.Handlers.Commands do - alias Lexical.Project + alias Forge.Project alias Lexical.Protocol.Requests alias Lexical.Protocol.Responses alias Lexical.Protocol.Types diff --git a/expert/lib/lexical/server/provider/handlers/hover.ex b/expert/lib/lexical/server/provider/handlers/hover.ex index a5de7ddf..a3a4adbe 100644 --- a/expert/lib/lexical/server/provider/handlers/hover.ex +++ b/expert/lib/lexical/server/provider/handlers/hover.ex @@ -3,7 +3,7 @@ defmodule Expert.Provider.Handlers.Hover do alias Lexical.Ast.Analysis alias Forge.Document alias Forge.Document.Position - alias Lexical.Project + alias Forge.Project alias Lexical.Protocol.Requests alias Lexical.Protocol.Responses alias Lexical.Protocol.Types.Hover From b73eb6d5734344223cff698ccae02fd5102c9cb7 Mon Sep 17 00:00:00 2001 From: Mitchell Hanberg Date: Sat, 11 Jan 2025 17:27:19 -0500 Subject: [PATCH 11/12] wip: rename a lot of stuff, move a lot more into forge --- engine/lib/engine.ex | 6 +- engine/lib/engine/application.ex | 4 +- engine/lib/engine/commands/reindex.ex | 2 +- engine/lib/engine/completion.ex | 4 +- engine/lib/engine/search/fuzzy.ex | 2 +- engine/lib/engine/search/indexer.ex | 6 +- engine/lib/engine/search/store.ex | 2 +- engine/lib/engine/search/store/backend.ex | 2 +- .../lib/engine/search/store/backends/ets.ex | 2 +- .../search/store/backends/ets/schema.ex | 2 +- .../search/store/backends/ets/schemas/v1.ex | 2 +- .../search/store/backends/ets/schemas/v2.ex | 2 +- .../search/store/backends/ets/schemas/v3.ex | 2 +- .../engine/search/store/backends/ets/state.ex | 2 +- engine/lib/engine/search/store/state.ex | 2 +- expert/lib/expert.ex | 32 +---- expert/lib/expert/api.ex | 2 +- .../lexical.plugin.diagnostic.result.ex | 4 +- expert/lib/lexical/logging.ex | 34 +++++ .../server/code_intelligence/completion.ex | 19 +-- .../code_intelligence/completion/builder.ex | 37 +++--- .../completion/translatable.ex | 6 +- .../translations/bitstring_option.ex | 4 +- .../completion/translations/callable.ex | 4 +- .../completion/translations/callback.ex | 4 +- .../completion/translations/function.ex | 4 +- .../completion/translations/macro.ex | 4 +- .../completion/translations/map_field.ex | 4 +- .../translations/module_attribute.ex | 4 +- .../translations/module_or_behaviour.ex | 4 +- .../completion/translations/struct.ex | 2 +- .../completion/translations/struct_field.ex | 4 +- .../completion/translations/typespec.ex | 4 +- .../completion/translations/variable.ex | 4 +- expert/lib/lexical/server/configuration.ex | 9 +- .../lexical/server/configuration/support.ex | 2 +- expert/lib/lexical/server/iex/helpers.ex | 2 +- .../lib/lexical/server/project/diagnostics.ex | 1 - .../server/project/diagnostics/state.ex | 2 +- .../server/provider/handlers/code_action.ex | 13 +- .../server/provider/handlers/commands.ex | 117 +++++++++--------- .../server/provider/handlers/completion.ex | 7 +- .../provider/handlers/document_symbols.ex | 4 +- .../lexical/server/provider/handlers/hover.ex | 2 +- .../provider/handlers/workspace_symbol.ex | 4 +- .../lib/lexical/server/provider/markdown.ex | 5 +- expert/lib/lexical/server/state.ex | 4 +- .../engine => forge/lib/forge}/analyzer.ex | 10 +- .../lib/forge}/analyzer/aliases.ex | 2 +- .../lib/forge}/analyzer/imports.ex | 4 +- .../lib/forge}/analyzer/requires.ex | 2 +- .../lib/forge}/analyzer/uses.ex | 2 +- .../engine => forge/lib/forge}/code_action.ex | 6 +- .../lib/forge}/code_action/diagnostic.ex | 2 +- .../lib/forge}/code_action/handler.ex | 6 +- .../forge}/code_action/handlers/add_alias.ex | 10 +- .../code_action/handlers/organize_aliases.ex | 4 +- .../handlers/remove_unused_alias.ex | 8 +- .../handlers/replace_remote_function.ex | 8 +- .../handlers/replace_with_underscore.ex | 6 +- .../forge}/code_intelligence/definition.ex | 6 +- .../lib/forge}/code_intelligence/docs.ex | 4 +- .../forge}/code_intelligence/docs/entry.ex | 2 +- .../lib/forge}/code_intelligence/entity.ex | 20 +-- .../forge}/code_intelligence/references.ex | 10 +- .../lib/forge}/code_intelligence/structs.ex | 4 +- .../lib/forge}/code_intelligence/symbols.ex | 10 +- .../code_intelligence/symbols/document.ex | 4 +- .../code_intelligence/symbols/workspace.ex | 4 +- .../lib/forge}/code_intelligence/variable.ex | 6 +- .../lib/forge}/completion/candidate.ex | 4 +- .../completion/candidate/argument_names.ex | 2 +- .../lib/forge}/search/fuzzy/scorer.ex | 0 .../lib/forge}/search/indexer/entry.ex | 4 +- .../search/indexer/extractors/ecto_schema.ex | 10 +- .../search/indexer/extractors/ex_unit.ex | 10 +- .../indexer/extractors/function_definition.ex | 8 +- .../indexer/extractors/function_reference.ex | 16 +-- .../search/indexer/extractors/module.ex | 14 +-- .../indexer/extractors/module_attribute.ex | 8 +- .../indexer/extractors/struct_definition.ex | 8 +- .../indexer/extractors/struct_reference.ex | 8 +- .../search/indexer/extractors/variable.ex | 8 +- .../lib/forge}/search/indexer/metadata.ex | 2 +- .../lib/forge}/search/indexer/module.ex | 4 +- .../lib/forge}/search/indexer/quoted.ex | 4 +- .../lib/forge}/search/indexer/source.ex | 4 +- .../lib/forge}/search/indexer/source/block.ex | 2 +- .../forge}/search/indexer/source/reducer.ex | 10 +- 89 files changed, 330 insertions(+), 330 deletions(-) create mode 100644 expert/lib/lexical/logging.ex rename {engine/lib/engine => forge/lib/forge}/analyzer.ex (97%) rename {engine/lib/engine => forge/lib/forge}/analyzer/aliases.ex (97%) rename {engine/lib/engine => forge/lib/forge}/analyzer/imports.ex (98%) rename {engine/lib/engine => forge/lib/forge}/analyzer/requires.ex (94%) rename {engine/lib/engine => forge/lib/forge}/analyzer/uses.ex (94%) rename {engine/lib/engine => forge/lib/forge}/code_action.ex (93%) rename {engine/lib/engine => forge/lib/forge}/code_action/diagnostic.ex (91%) rename {engine/lib/engine => forge/lib/forge}/code_action/handler.ex (65%) rename {engine/lib/engine => forge/lib/forge}/code_action/handlers/add_alias.ex (97%) rename {engine/lib/engine => forge/lib/forge}/code_action/handlers/organize_aliases.ex (93%) rename {engine/lib/engine => forge/lib/forge}/code_action/handlers/remove_unused_alias.ex (98%) rename {engine/lib/engine => forge/lib/forge}/code_action/handlers/replace_remote_function.ex (95%) rename {engine/lib/engine => forge/lib/forge}/code_action/handlers/replace_with_underscore.ex (94%) rename {engine/lib/engine => forge/lib/forge}/code_intelligence/definition.ex (97%) rename {engine/lib/engine => forge/lib/forge}/code_intelligence/docs.ex (97%) rename {engine/lib/engine => forge/lib/forge}/code_intelligence/docs/entry.ex (96%) rename {engine/lib/engine => forge/lib/forge}/code_intelligence/entity.ex (96%) rename {engine/lib/engine => forge/lib/forge}/code_intelligence/references.ex (93%) rename {engine/lib/engine => forge/lib/forge}/code_intelligence/structs.ex (86%) rename {engine/lib/engine => forge/lib/forge}/code_intelligence/symbols.ex (94%) rename {engine/lib/engine => forge/lib/forge}/code_intelligence/symbols/document.ex (96%) rename {engine/lib/engine => forge/lib/forge}/code_intelligence/symbols/workspace.ex (92%) rename {engine/lib/engine => forge/lib/forge}/code_intelligence/variable.ex (98%) rename {engine/lib/engine => forge/lib/forge}/completion/candidate.ex (98%) rename {engine/lib/engine => forge/lib/forge}/completion/candidate/argument_names.ex (98%) rename {engine/lib/engine => forge/lib/forge}/search/fuzzy/scorer.ex (100%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/entry.ex (98%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/extractors/ecto_schema.ex (93%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/extractors/ex_unit.ex (95%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/extractors/function_definition.ex (95%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/extractors/function_reference.ex (93%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/extractors/module.ex (96%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/extractors/module_attribute.ex (94%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/extractors/struct_definition.ex (80%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/extractors/struct_reference.ex (94%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/extractors/variable.ex (97%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/metadata.ex (97%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/module.ex (89%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/quoted.ex (87%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/source.ex (82%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/source/block.ex (87%) rename {engine/lib/engine => forge/lib/forge}/search/indexer/source/reducer.ex (95%) diff --git a/engine/lib/engine.ex b/engine/lib/engine.ex index c3a60d5d..2f471fe0 100644 --- a/engine/lib/engine.ex +++ b/engine/lib/engine.ex @@ -8,8 +8,8 @@ defmodule Engine do alias Forge.Project alias Engine.Api.Proxy - alias Engine.CodeAction - alias Engine.CodeIntelligence + alias Forge.CodeAction + alias Forge.CodeIntelligence alias Engine.ProjectNode require Logger @@ -29,7 +29,7 @@ defmodule Engine do defdelegate broadcast(message), to: Proxy - defdelegate expand_alias(segments_or_module, analysis, position), to: Engine.Analyzer + defdelegate expand_alias(segments_or_module, analysis, position), to: Forge.Analyzer defdelegate list_modules, to: :code, as: :all_available diff --git a/engine/lib/engine/application.ex b/engine/lib/engine/application.ex index 55ee379e..5ba99be4 100644 --- a/engine/lib/engine/application.ex +++ b/engine/lib/engine/application.ex @@ -19,8 +19,8 @@ defmodule Engine.Application do Engine.Search.Store.Backends.Ets, {Engine.Search.Store, [ - &Engine.Search.Indexer.create_index/1, - &Engine.Search.Indexer.update_index/2 + &Forge.Search.Indexer.create_index/1, + &Forge.Search.Indexer.update_index/2 ]} ] else diff --git a/engine/lib/engine/commands/reindex.ex b/engine/lib/engine/commands/reindex.ex index 3590f85f..65e860ec 100644 --- a/engine/lib/engine/commands/reindex.ex +++ b/engine/lib/engine/commands/reindex.ex @@ -4,7 +4,7 @@ defmodule Engine.Commands.Reindex do alias Forge.Document alias Forge.ProcessCache alias Engine.Search - alias Engine.Search.Indexer + alias Forge.Search.Indexer require Logger require ProcessCache diff --git a/engine/lib/engine/completion.ex b/engine/lib/engine/completion.ex index 79e85418..41afd67c 100644 --- a/engine/lib/engine/completion.ex +++ b/engine/lib/engine/completion.ex @@ -5,7 +5,7 @@ defmodule Engine.Completion do alias Forge.Document.Position alias Engine.CodeMod.Format - alias Engine.Completion.Candidate + alias Forge.Completion.Candidate import Document.Line @@ -62,7 +62,7 @@ defmodule Engine.Completion do |> container_struct_module() with {:ok, struct_module} <- - Engine.Analyzer.expand_alias(container_struct_module, analysis, position), + Forge.Analyzer.expand_alias(container_struct_module, analysis, position), true <- function_exported?(struct_module, :__struct__, 0) do struct_module |> struct() diff --git a/engine/lib/engine/search/fuzzy.ex b/engine/lib/engine/search/fuzzy.ex index 9baa8a71..16b733df 100644 --- a/engine/lib/engine/search/fuzzy.ex +++ b/engine/lib/engine/search/fuzzy.ex @@ -14,7 +14,7 @@ defmodule Engine.Search.Fuzzy do alias Forge.Project alias Engine.Search.Fuzzy.Scorer - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry import Record defstruct subject_to_values: %{}, diff --git a/engine/lib/engine/search/indexer.ex b/engine/lib/engine/search/indexer.ex index 41dd4db0..d86859fa 100644 --- a/engine/lib/engine/search/indexer.ex +++ b/engine/lib/engine/search/indexer.ex @@ -1,11 +1,11 @@ -defmodule Engine.Search.Indexer do +defmodule Forge.Search.Indexer do alias Forge.Identifier alias Forge.ProcessCache alias Forge.Project alias Engine.Progress - alias Engine.Search.Indexer - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer + alias Forge.Search.Indexer.Entry require ProcessCache diff --git a/engine/lib/engine/search/store.ex b/engine/lib/engine/search/store.ex index 0cede683..0d3435b3 100644 --- a/engine/lib/engine/search/store.ex +++ b/engine/lib/engine/search/store.ex @@ -6,7 +6,7 @@ defmodule Engine.Search.Store do alias Forge.Project alias Forge.Api - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry alias Engine.Search.Store alias Engine.Search.Store.State diff --git a/engine/lib/engine/search/store/backend.ex b/engine/lib/engine/search/store/backend.ex index 7a11857d..9313c317 100644 --- a/engine/lib/engine/search/store/backend.ex +++ b/engine/lib/engine/search/store/backend.ex @@ -3,7 +3,7 @@ defmodule Engine.Search.Store.Backend do A behaviour for search store backends """ alias Forge.Project - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry @type version :: pos_integer() @type priv_state :: term() diff --git a/engine/lib/engine/search/store/backends/ets.ex b/engine/lib/engine/search/store/backends/ets.ex index d2d21dd8..9cf97670 100644 --- a/engine/lib/engine/search/store/backends/ets.ex +++ b/engine/lib/engine/search/store/backends/ets.ex @@ -1,7 +1,7 @@ defmodule Engine.Search.Store.Backends.Ets do alias Forge.Project - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry alias Engine.Search.Store.Backend alias Engine.Search.Store.Backends.Ets.State diff --git a/engine/lib/engine/search/store/backends/ets/schema.ex b/engine/lib/engine/search/store/backends/ets/schema.ex index b9d8dba4..3618c979 100644 --- a/engine/lib/engine/search/store/backends/ets/schema.ex +++ b/engine/lib/engine/search/store/backends/ets/schema.ex @@ -44,7 +44,7 @@ defmodule Engine.Search.Store.Backends.Ets.Schema do end alias Forge.Project - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry alias Engine.Search.Store.Backends.Ets.Wal import Wal, only: :macros diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v1.ex b/engine/lib/engine/search/store/backends/ets/schemas/v1.ex index 7f076f0e..131051fc 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/v1.ex +++ b/engine/lib/engine/search/store/backends/ets/schemas/v1.ex @@ -9,7 +9,7 @@ defmodule Engine.Search.Store.Backends.Ets.Schemas.V1 do """ - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry alias Engine.Search.Store.Backends.Ets.Schema use Schema, version: 1 diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v2.ex b/engine/lib/engine/search/store/backends/ets/schemas/v2.ex index af3e189e..f67b7016 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/v2.ex +++ b/engine/lib/engine/search/store/backends/ets/schemas/v2.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Store.Backends.Ets.Schemas.V2 do - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry alias Engine.Search.Store.Backends.Ets.Schema require Entry diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v3.ex b/engine/lib/engine/search/store/backends/ets/schemas/v3.ex index c59abc4e..64507e5a 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/v3.ex +++ b/engine/lib/engine/search/store/backends/ets/schemas/v3.ex @@ -1,5 +1,5 @@ defmodule Engine.Search.Store.Backends.Ets.Schemas.V3 do - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry alias Engine.Search.Store.Backends.Ets.Schema require Entry diff --git a/engine/lib/engine/search/store/backends/ets/state.ex b/engine/lib/engine/search/store/backends/ets/state.ex index 6ac589e3..b190a86b 100644 --- a/engine/lib/engine/search/store/backends/ets/state.ex +++ b/engine/lib/engine/search/store/backends/ets/state.ex @@ -6,7 +6,7 @@ defmodule Engine.Search.Store.Backends.Ets.State do """ alias Forge.Project - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry alias Engine.Search.Store.Backends.Ets.Schema alias Engine.Search.Store.Backends.Ets.Schemas alias Engine.Search.Store.Backends.Ets.Wal diff --git a/engine/lib/engine/search/store/state.ex b/engine/lib/engine/search/store/state.ex index e3ad0c3f..4e89142e 100644 --- a/engine/lib/engine/search/store/state.ex +++ b/engine/lib/engine/search/store/state.ex @@ -3,7 +3,7 @@ defmodule Engine.Search.Store.State do alias Forge.Api.Messages alias Engine.Dispatch alias Engine.Search.Fuzzy - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry require Logger import Messages diff --git a/expert/lib/expert.ex b/expert/lib/expert.ex index a65cd2da..301f5a33 100644 --- a/expert/lib/expert.ex +++ b/expert/lib/expert.ex @@ -87,36 +87,6 @@ defmodule Expert do )} end - def handle_request( - %GenLSP.Requests.TextDocumentDocumentSymbol{params: %{text_document: %{uri: uri}}}, - lsp - ) do - path = URI.parse(uri).path - doc = File.read!(path) - - lsp = - if lsp.assigns[:runtime] == nil do - receive do - {:runtime_ready, _name, runtime_pid} = msg -> - send(self(), msg) - assign(lsp, ready: true, runtime: runtime_pid) - end - else - lsp - end - - symbols = - Expert.Runtime.execute! lsp.assigns.runtime do - Engine.DocumentSymbol.fetch(doc) - end - - # which then will get serialized again on the way out - # we could potentially namespace our app too, but i think that - # makes our dev experience worse - - {:reply, symbols, lsp} - end - def handle_request(%GenLSP.Requests.Shutdown{}, lsp) do {:reply, nil, assign(lsp, exit_code: 0)} end @@ -135,6 +105,8 @@ defmodule Expert do Logger.info("Log file located at #{Path.join(File.cwd!(), ".expert-lsp/expert.log")}") + Expert.Project.Supervisor.start() + {:noreply, lsp} end diff --git a/expert/lib/expert/api.ex b/expert/lib/expert/api.ex index 4510dd1e..a2cd3f82 100644 --- a/expert/lib/expert/api.ex +++ b/expert/lib/expert/api.ex @@ -6,7 +6,7 @@ defmodule Expert.Api do alias Forge.Document.Range alias Forge.Project - alias Engine.CodeIntelligence + alias Forge.CodeIntelligence require Logger diff --git a/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex b/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex index 1b48f0d5..e8c8dd84 100644 --- a/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex +++ b/expert/lib/lexical/convertibles/lexical.plugin.diagnostic.result.ex @@ -3,14 +3,14 @@ defimpl Forge.Convertible, for: Forge.Plugin.V1.Diagnostic.Result do alias Forge.Document.Position alias Forge.Document.Range alias Lexical.Math - alias Lexical.Plugin.V1.Diagnostic + alias Forge.Plugin.V1.Diagnostic alias Lexical.Protocol.Conversions alias Lexical.Protocol.Types alias Lexical.Text def to_lsp(%Diagnostic.Result{} = diagnostic) do with {:ok, lsp_range} <- lsp_range(diagnostic) do - proto_diagnostic = %Types.Diagnostic{ + proto_diagnostic = %GenLSP.Structures.Diagnostic{ message: diagnostic.message, range: lsp_range, severity: diagnostic.severity, diff --git a/expert/lib/lexical/logging.ex b/expert/lib/lexical/logging.ex new file mode 100644 index 00000000..82c6c2e0 --- /dev/null +++ b/expert/lib/lexical/logging.ex @@ -0,0 +1,34 @@ +defmodule Lexical.Logging do + require Logger + + defmacro timed(label, do: block) do + if enabled?() do + quote do + timed_log(unquote(label), fn -> unquote(block) end) + end + else + block + end + end + + def timed_log(label, threshold_ms \\ 1, function) when is_function(function, 0) do + if enabled?() do + {elapsed_us, result} = :timer.tc(function) + elapsed_ms = elapsed_us / 1000 + + if elapsed_ms >= threshold_ms do + Logger.info("#{label} took #{Lexical.Formats.time(elapsed_us)}") + end + + result + else + function.() + end + end + + @debug_enabled? not is_nil(System.get_env("TIMINGS_ENABLED")) + + defp enabled? do + @debug_enabled? + end +end diff --git a/expert/lib/lexical/server/code_intelligence/completion.ex b/expert/lib/lexical/server/code_intelligence/completion.ex index e273e203..4d3da6d4 100644 --- a/expert/lib/lexical/server/code_intelligence/completion.ex +++ b/expert/lib/lexical/server/code_intelligence/completion.ex @@ -4,11 +4,13 @@ defmodule Expert.CodeIntelligence.Completion do alias Forge.Ast.Env alias Forge.Document.Position alias Forge.Project - alias Engine.Completion.Candidate + alias Forge.Completion.Candidate alias Expert.CodeIntelligence.Completion.Builder alias Expert.CodeIntelligence.Completion.Translatable alias Expert.Configuration alias Expert.Project.Intelligence + alias GenLSP.Structures.CompletionContext + alias GenLSP.Structures.CompletionItem require Logger @@ -26,7 +28,7 @@ defmodule Expert.CodeIntelligence.Completion do %Project{} = project, %Analysis{} = analysis, %Position{} = position, - %Completion.Context{} = context + %CompletionContext{} = context ) do case Env.new(project, analysis, position) do {:ok, env} -> @@ -42,7 +44,7 @@ defmodule Expert.CodeIntelligence.Completion do defp log_candidates(candidates) do log_iolist = - Enum.reduce(candidates, ["Emitting Completions: ["], fn %Completion.Item{} = completion, + Enum.reduce(candidates, ["Emitting Completions: ["], fn %CompletionItem{} = completion, acc -> name = Map.get(completion, :name) || Map.get(completion, :label) kind = completion |> Map.get(:kind, :unknown) |> to_string() @@ -53,7 +55,7 @@ defmodule Expert.CodeIntelligence.Completion do Logger.info([log_iolist, "]"]) end - defp completions(%Project{} = project, %Env{} = env, %Completion.Context{} = context) do + defp completions(%Project{} = project, %Env{} = env, %CompletionContext{} = context) do prefix_tokens = Env.prefix_tokens(env, 1) cond do @@ -158,7 +160,7 @@ defmodule Expert.CodeIntelligence.Completion do local_completions, %Project{} = project, %Env{} = env, - %Completion.Context{} = context + %CompletionContext{} = context ) do debug_local_completions(local_completions) @@ -166,7 +168,7 @@ defmodule Expert.CodeIntelligence.Completion do displayable?(project, result), applies_to_context?(project, result, context), applies_to_env?(env, result), - %Completion.Item{} = item <- to_completion_item(result, env) do + %CompletionItem{} = item <- to_completion_item(result, env) do item end end @@ -334,8 +336,9 @@ defmodule Expert.CodeIntelligence.Completion do false end - defp applies_to_context?(%Project{} = project, result, %Completion.Context{ - trigger_kind: :trigger_character, + @trigger_character GenLSP.Enumerations.CompletionTriggerKind.trigger_character() + defp applies_to_context?(%Project{} = project, result, %CompletionContext{ + trigger_kind: @trigger_character, trigger_character: "%" }) do case result do diff --git a/expert/lib/lexical/server/code_intelligence/completion/builder.ex b/expert/lib/lexical/server/code_intelligence/completion/builder.ex index e0c11ae8..445e1c75 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/builder.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/builder.ex @@ -11,35 +11,35 @@ defmodule Expert.CodeIntelligence.Completion.Builder do """ alias Future.Code, as: Code - alias Lexical.Ast.Env + alias Forge.Ast.Env alias Forge.Document alias Forge.Document.Edit alias Forge.Document.Position alias Forge.Document.Range - alias Lexical.Protocol.Types.Completion - alias Lexical.Protocol.Types.Markup.Content + alias GenLSP.Structures.CompletionItem + alias GenLSP.Structures.MarkupContent alias Expert.CodeIntelligence.Completion.SortScope - @doc "Fields found in `t:Lexical.Protocol.Types.Completion.Item.t()`" + @doc "Fields found in `t:GenLSP.Structures.CompletionItem.t()`" @type item_opts :: keyword() @type t :: module() @type line_range :: {start_character :: pos_integer, end_character :: pos_integer} - @spec snippet(Env.t(), String.t(), item_opts) :: Completion.Item.t() + @spec snippet(Env.t(), String.t(), item_opts) :: CompletionItem.t() def snippet(%Env{} = env, text, options \\ []) do range = prefix_range(env) text_edit_snippet(env, text, range, options) end - @spec plain_text(Env.t(), String.t(), item_opts) :: Completion.Item.t() + @spec plain_text(Env.t(), String.t(), item_opts) :: CompletionItem.t() def plain_text(%Env{} = env, text, options \\ []) do range = prefix_range(env) text_edit(env, text, range, options) end - @spec text_edit(Env.t(), String.t(), line_range, item_opts) :: Completion.Item.t() + @spec text_edit(Env.t(), String.t(), line_range, item_opts) :: CompletionItem.t() def text_edit(%Env{} = env, text, {start_char, end_char}, options \\ []) do line_number = env.position.line @@ -53,12 +53,12 @@ defmodule Expert.CodeIntelligence.Completion.Builder do options |> Keyword.put(:text_edit, edits) - |> Completion.Item.new() + |> then(&struct(CompletionItem, &1)) |> markdown_docs() |> set_sort_scope(SortScope.default()) end - @spec text_edit_snippet(Env.t(), String.t(), line_range, item_opts) :: Completion.Item.t() + @spec text_edit_snippet(Env.t(), String.t(), line_range, item_opts) :: CompletionItem.t() def text_edit_snippet(%Env{} = env, text, {start_char, end_char}, options \\ []) do snippet = String.trim_trailing(text, "\n") line_number = env.position.line @@ -74,7 +74,7 @@ defmodule Expert.CodeIntelligence.Completion.Builder do options |> Keyword.put(:text_edit, edits) |> Keyword.put(:insert_text_format, :snippet) - |> Completion.Item.new() + |> then(&struct(CompletionItem, &1)) |> markdown_docs() |> set_sort_scope(SortScope.default()) end @@ -84,10 +84,10 @@ defmodule Expert.CodeIntelligence.Completion.Builder do def fallback("", fallback), do: fallback def fallback(detail, _), do: detail - @spec set_sort_scope(Completion.Item.t(), sort_scope :: String.t()) :: Completion.Item.t() + @spec set_sort_scope(CompletionItem.t(), sort_scope :: String.t()) :: CompletionItem.t() def set_sort_scope(item, default \\ SortScope.default()) - def set_sort_scope(%Completion.Item{} = item, sort_scope) + def set_sort_scope(%CompletionItem{} = item, sort_scope) when is_binary(sort_scope) do stripped_sort_text = item.sort_text @@ -95,7 +95,7 @@ defmodule Expert.CodeIntelligence.Completion.Builder do |> strip_sort_text() sort_text = "0#{sort_scope}_#{stripped_sort_text}" - %Completion.Item{item | sort_text: sort_text} + %CompletionItem{item | sort_text: sort_text} end # private @@ -176,10 +176,17 @@ defmodule Expert.CodeIntelligence.Completion.Builder do String.replace(sort_text, @sort_prefix_re, "") end - defp markdown_docs(%Completion.Item{} = item) do + defp markdown_docs(%CompletionItem{} = item) do case item.documentation do doc when is_binary(doc) -> - %{item | documentation: %Content{kind: :markdown, value: doc}} + # FIXME: fix the content kind + %{ + item + | documentation: %MarkupContent{ + kind: GenLSP.Enumerations.MarkupKind.markdown(), + value: doc + } + } _ -> item diff --git a/expert/lib/lexical/server/code_intelligence/completion/translatable.ex b/expert/lib/lexical/server/code_intelligence/completion/translatable.ex index f6d75b4c..d391eb71 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translatable.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translatable.ex @@ -1,11 +1,11 @@ defprotocol Expert.CodeIntelligence.Completion.Translatable do - alias Lexical.Ast.Env - alias Lexical.Protocol.Types.Completion + alias Forge.Ast.Env + alias GenLSP.Structures.CompletionItem alias Expert.CodeIntelligence.Completion.Builder @type t :: any() - @type translated :: [Completion.Item.t()] | Completion.Item.t() | :skip + @type translated :: [CompletionItem.t()] | CompletionItem.t() | :skip @fallback_to_any true @spec translate(t, Builder.t(), Env.t()) :: translated diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex index c74ef057..159ea892 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/bitstring_option.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.BitstringOption do - alias Lexical.Ast.Env - alias Engine.Completion.Candidate + alias Forge.Ast.Env + alias Forge.Completion.Candidate alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex index f8ee159f..74e87b48 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/callable.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Callable do - alias Lexical.Ast.Env - alias Engine.Completion.Candidate + alias Forge.Ast.Env + alias Forge.Completion.Candidate alias Expert.CodeIntelligence.Completion.Builder alias Expert.CodeIntelligence.Completion.SortScope diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex index d7e06b69..6598745f 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/callback.ex @@ -1,7 +1,7 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Callback do - alias Lexical.Ast.Env + alias Forge.Ast.Env alias Forge.Document - alias Engine.Completion.Candidate.Callback + alias Forge.Completion.Candidate.Callback alias Expert.CodeIntelligence.Completion.Builder alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex index e995c92c..1ef5dcb2 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/function.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Function do - alias Lexical.Ast.Env - alias Engine.Completion.Candidate + alias Forge.Ast.Env + alias Forge.Completion.Candidate alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex index 26b21517..4349dc4c 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/macro.ex @@ -1,9 +1,9 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Macro do alias Lexical.Ast - alias Lexical.Ast.Env + alias Forge.Ast.Env alias Forge.Document alias Forge.Document.Position - alias Engine.Completion.Candidate + alias Forge.Completion.Candidate alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex index 4b7f2bd2..fee3495e 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/map_field.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.MapField do - alias Lexical.Ast.Env - alias Engine.Completion.Candidate + alias Forge.Ast.Env + alias Forge.Completion.Candidate alias Expert.CodeIntelligence.Completion.Translatable defimpl Translatable, for: Candidate.MapField do diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex index 6d26980f..26d7f29c 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/module_attribute.ex @@ -1,8 +1,8 @@ defmodule Expert.CodeIntelligence.Completion.Translations.ModuleAttribute do alias Lexical.Ast - alias Lexical.Ast.Env + alias Forge.Ast.Env alias Forge.Document.Position - alias Engine.Completion.Candidate + alias Forge.Completion.Candidate alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex index d051c11a..d5cea99b 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/module_or_behaviour.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.ModuleOrBehaviour do - alias Lexical.Ast.Env - alias Engine.Completion.Candidate + alias Forge.Ast.Env + alias Forge.Completion.Candidate alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/struct.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/struct.ex index d6049bbb..2a52baeb 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/struct.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/struct.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Struct do alias Future.Code, as: Code - alias Lexical.Ast.Env + alias Forge.Ast.Env alias Lexical.Formats def completion(%Env{} = _env, _builder, _module_name, _full_name, 0) do diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex index 71173333..7f91f5b8 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/struct_field.ex @@ -1,7 +1,7 @@ defmodule Expert.CodeIntelligence.Completion.Translations.StructField do alias Future.Code, as: Code - alias Lexical.Ast.Env - alias Engine.Completion.Candidate + alias Forge.Ast.Env + alias Forge.Completion.Candidate alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex index 62dbf06b..18831862 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/typespec.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Typespec do - alias Lexical.Ast.Env - alias Engine.Completion.Candidate + alias Forge.Ast.Env + alias Forge.Completion.Candidate alias Expert.CodeIntelligence.Completion.Translatable alias Expert.CodeIntelligence.Completion.Translations.Callable diff --git a/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex b/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex index ce3323ab..5a3a945b 100644 --- a/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex +++ b/expert/lib/lexical/server/code_intelligence/completion/translations/variable.ex @@ -1,6 +1,6 @@ defmodule Expert.CodeIntelligence.Completion.Translations.Variable do - alias Lexical.Ast.Env - alias Engine.Completion.Candidate + alias Forge.Ast.Env + alias Forge.Completion.Candidate alias Expert.CodeIntelligence.Completion.SortScope alias Expert.CodeIntelligence.Completion.Translatable diff --git a/expert/lib/lexical/server/configuration.ex b/expert/lib/lexical/server/configuration.ex index 1d675bbb..fa683e2d 100644 --- a/expert/lib/lexical/server/configuration.ex +++ b/expert/lib/lexical/server/configuration.ex @@ -4,11 +4,8 @@ defmodule Expert.Configuration do """ alias Forge.Project - alias Lexical.Protocol.Id - alias Lexical.Protocol.Notifications.DidChangeConfiguration - alias Lexical.Protocol.Requests - alias Lexical.Protocol.Requests.RegisterCapability - alias Lexical.Protocol.Types.ClientCapabilities + alias GenLSP.Notifications.WorkspaceDidChangeConfiguration + alias GenLSP.Structures.ClientCapabilities alias Lexical.Protocol.Types.Registration alias Expert.Configuration.Support alias Expert.Dialyzer @@ -84,7 +81,7 @@ defmodule Expert.Configuration do apply_config_change(old_config, default_config()) end - def on_change(%__MODULE__{} = old_config, %DidChangeConfiguration{} = change) do + def on_change(%__MODULE__{} = old_config, %WorkspaceDidChangeConfiguration{} = change) do apply_config_change(old_config, change.lsp.settings) end diff --git a/expert/lib/lexical/server/configuration/support.ex b/expert/lib/lexical/server/configuration/support.ex index 24f83dd3..a6420069 100644 --- a/expert/lib/lexical/server/configuration/support.ex +++ b/expert/lib/lexical/server/configuration/support.ex @@ -1,7 +1,7 @@ defmodule Expert.Configuration.Support do @moduledoc false - alias Lexical.Protocol.Types.ClientCapabilities + alias GenLSP.Structures.ClientCapabilities # To track a new client capability, add a new field and the path to the # capability in the `Lexical.Protocol.Types.ClientCapabilities` struct diff --git a/expert/lib/lexical/server/iex/helpers.ex b/expert/lib/lexical/server/iex/helpers.ex index 93ac79f9..1400446d 100644 --- a/expert/lib/lexical/server/iex/helpers.ex +++ b/expert/lib/lexical/server/iex/helpers.ex @@ -1,5 +1,5 @@ defmodule Expert.IEx.Helpers do - alias Lexical.Ast + alias Forge.Ast alias Forge.Document alias Forge.Document.Position alias Forge.Project diff --git a/expert/lib/lexical/server/project/diagnostics.ex b/expert/lib/lexical/server/project/diagnostics.ex index 1f33956d..28e49cae 100644 --- a/expert/lib/lexical/server/project/diagnostics.ex +++ b/expert/lib/lexical/server/project/diagnostics.ex @@ -3,7 +3,6 @@ defmodule Expert.Project.Diagnostics do alias Forge.Project alias Lexical.Protocol.Notifications.PublishDiagnostics alias Engine - alias Forge.Api.Messages alias Expert.Project.Diagnostics.State alias Expert.Transport diff --git a/expert/lib/lexical/server/project/diagnostics/state.ex b/expert/lib/lexical/server/project/diagnostics/state.ex index 2bcd93a5..5eaa41a2 100644 --- a/expert/lib/lexical/server/project/diagnostics/state.ex +++ b/expert/lib/lexical/server/project/diagnostics/state.ex @@ -29,7 +29,7 @@ defmodule Expert.Project.Diagnostics.State do end alias Forge.Document - alias Lexical.Plugin.V1.Diagnostic + alias Forge.Plugin.V1.Diagnostic alias Forge.Project defstruct project: nil, entries_by_uri: %{} diff --git a/expert/lib/lexical/server/provider/handlers/code_action.ex b/expert/lib/lexical/server/provider/handlers/code_action.ex index 4f54598c..1198290c 100644 --- a/expert/lib/lexical/server/provider/handlers/code_action.ex +++ b/expert/lib/lexical/server/provider/handlers/code_action.ex @@ -1,15 +1,14 @@ defmodule Expert.Provider.Handlers.CodeAction do alias Lexical.Protocol.Requests - alias Lexical.Protocol.Responses - alias Lexical.Protocol.Types - alias Lexical.Protocol.Types.Workspace - alias Engine - alias Engine.CodeAction + alias GenLSP.Requests.TextDocumentCodeAction + alias GenLSP.Structures.Diagnostic + alias GenLSP.Structures.WorkspaceEdit + alias Forge.CodeAction alias Expert.Configuration require Logger - def handle(%Requests.CodeAction{} = request, %Configuration{} = config) do + def handle(%TextDocumentCodeAction{} = request, %Configuration{} = config) do diagnostics = Enum.map(request.context.diagnostics, &to_code_action_diagnostic/1) code_actions = @@ -27,7 +26,7 @@ defmodule Expert.Provider.Handlers.CodeAction do {:reply, reply} end - defp to_code_action_diagnostic(%Types.Diagnostic{} = diagnostic) do + defp to_code_action_diagnostic(%Diagnostic{} = diagnostic) do CodeAction.Diagnostic.new(diagnostic.range, diagnostic.message, diagnostic.source) end diff --git a/expert/lib/lexical/server/provider/handlers/commands.ex b/expert/lib/lexical/server/provider/handlers/commands.ex index 49b957c0..6e21f2e5 100644 --- a/expert/lib/lexical/server/provider/handlers/commands.ex +++ b/expert/lib/lexical/server/provider/handlers/commands.ex @@ -1,60 +1,57 @@ -defmodule Expert.Provider.Handlers.Commands do - alias Forge.Project - alias Lexical.Protocol.Requests - alias Lexical.Protocol.Responses - alias Lexical.Protocol.Types - alias Lexical.Protocol.Types.ErrorCodes - alias Engine - alias Expert.Configuration - alias Expert.Window - - require ErrorCodes - require Logger - - @reindex_name "Reindex" - - def names do - [@reindex_name] - end - - def reindex_command(%Project{} = project) do - project_name = Project.name(project) - - Types.Command.new( - title: "Rebuild #{project_name}'s code search index", - command: @reindex_name - ) - end - - def handle(%Requests.ExecuteCommand{} = request, %Configuration{} = config) do - response = - case request.command do - @reindex_name -> - Logger.info("Reindex #{Project.name(config.project)}") - reindex(config.project, request.id) - - invalid -> - message = "#{invalid} is not a valid command" - internal_error(request.id, message) - end - - {:reply, response} - end - - defp reindex(%Project{} = project, request_id) do - case Engine.Api.reindex(project) do - :ok -> - Responses.ExecuteCommand.new(request_id, "ok") - - error -> - Window.show_error_message("Indexing #{Project.name(project)} failed") - Logger.error("Indexing command failed due to #{inspect(error)}") - - internal_error(request_id, "Could not reindex: #{error}") - end - end - - defp internal_error(request_id, message) do - Responses.ExecuteCommand.error(request_id, :internal_error, message) - end -end +# defmodule Expert.Provider.Handlers.Commands do +# alias Forge.Project +# alias Expert.Configuration +# alias Expert.Window +# +# require Logger +# +# @reindex_name "Reindex" +# +# def names do +# [@reindex_name] +# end +# +# def reindex_command(%Project{} = project) do +# project_name = Project.name(project) +# +# %GenLSP.Structures.Command{ +# title: "Rebuild #{project_name}'s code search index", +# command: @reindex_name +# } +# end +# +# # def handle( +# # %GenLSP.Requests.WorkspaceExecuteCommand{params: params} = request, +# # %Configuration{} = config +# # ) do +# # response = +# # case params.command do +# # @reindex_name -> +# # Logger.info("Reindex #{Project.name(config.project)}") +# # reindex(config.project, request.id) +# # +# # invalid -> +# # message = "#{invalid} is not a valid command" +# # internal_error(request.id, message) +# # end +# # +# # {:reply, response} +# # end +# +# # defp reindex(%Project{} = project, request_id) do +# # case Engine.Api.reindex(project) do +# # :ok -> +# # Responses.ExecuteCommand.new(request_id, "ok") +# # +# # error -> +# # Window.show_error_message("Indexing #{Project.name(project)} failed") +# # Logger.error("Indexing command failed due to #{inspect(error)}") +# # +# # internal_error(request_id, "Could not reindex: #{error}") +# # end +# # end +# # +# # defp internal_error(request_id, message) do +# # Responses.ExecuteCommand.error(request_id, :internal_error, message) +# # end +# end diff --git a/expert/lib/lexical/server/provider/handlers/completion.ex b/expert/lib/lexical/server/provider/handlers/completion.ex index aa55ad6b..634ba4ca 100644 --- a/expert/lib/lexical/server/provider/handlers/completion.ex +++ b/expert/lib/lexical/server/provider/handlers/completion.ex @@ -2,9 +2,7 @@ defmodule Expert.Provider.Handlers.Completion do alias Lexical.Ast alias Forge.Document alias Forge.Document.Position - alias Lexical.Protocol.Requests - alias Lexical.Protocol.Responses - alias Lexical.Protocol.Types.Completion + alias GenLSP.Structures.CompletionContext alias Expert.CodeIntelligence alias Expert.Configuration @@ -16,7 +14,8 @@ defmodule Expert.Provider.Handlers.Completion do config.project, document_analysis(request.document, request.position), request.position, - request.context || Completion.Context.new(trigger_kind: :invoked) + request.context || + %CompletionContext{trigger_kind: GenLSP.Enumerations.CompletionTriggerKind.invoked()} ) response = Responses.Completion.new(request.id, completions) diff --git a/expert/lib/lexical/server/provider/handlers/document_symbols.ex b/expert/lib/lexical/server/provider/handlers/document_symbols.ex index 0d64b786..01c90ec3 100644 --- a/expert/lib/lexical/server/provider/handlers/document_symbols.ex +++ b/expert/lib/lexical/server/provider/handlers/document_symbols.ex @@ -5,11 +5,9 @@ defmodule Expert.Provider.Handlers.DocumentSymbols do alias Lexical.Protocol.Types.Document.Symbol alias Lexical.Protocol.Types.Symbol.Kind, as: SymbolKind alias Engine.Api - alias Engine.CodeIntelligence.Symbols + alias Forge.CodeIntelligence.Symbols alias Expert.Configuration - require SymbolKind - def handle(%DocumentSymbols{} = request, %Configuration{} = config) do symbols = config.project diff --git a/expert/lib/lexical/server/provider/handlers/hover.ex b/expert/lib/lexical/server/provider/handlers/hover.ex index a3a4adbe..b72851a0 100644 --- a/expert/lib/lexical/server/provider/handlers/hover.ex +++ b/expert/lib/lexical/server/provider/handlers/hover.ex @@ -8,7 +8,7 @@ defmodule Expert.Provider.Handlers.Hover do alias Lexical.Protocol.Responses alias Lexical.Protocol.Types.Hover alias Engine - alias Engine.CodeIntelligence.Docs + alias Forge.CodeIntelligence.Docs alias Expert.Configuration alias Expert.Provider.Markdown diff --git a/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex b/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex index dd1d181d..4f52664b 100644 --- a/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex +++ b/expert/lib/lexical/server/provider/handlers/workspace_symbol.ex @@ -5,11 +5,9 @@ defmodule Expert.Provider.Handlers.WorkspaceSymbol do alias Lexical.Protocol.Types.Symbol.Kind, as: SymbolKind alias Lexical.Protocol.Types.Workspace.Symbol alias Engine.Api - alias Engine.CodeIntelligence.Symbols + alias Forge.CodeIntelligence.Symbols alias Expert.Configuration - require SymbolKind - require Logger def handle(%WorkspaceSymbol{} = request, %Configuration{} = config) do diff --git a/expert/lib/lexical/server/provider/markdown.ex b/expert/lib/lexical/server/provider/markdown.ex index ef35e06a..0257d738 100644 --- a/expert/lib/lexical/server/provider/markdown.ex +++ b/expert/lib/lexical/server/provider/markdown.ex @@ -3,8 +3,7 @@ defmodule Expert.Provider.Markdown do Utilities for formatting Markdown content. """ - alias Lexical.Protocol.Types.Markup - + alias GenLSP.Structures.MarkupContent @type markdown :: String.t() @doc """ @@ -12,7 +11,7 @@ defmodule Expert.Provider.Markdown do """ @spec to_content(markdown) :: Markup.Content.t() def to_content(markdown) when is_binary(markdown) do - %Markup.Content{kind: :markdown, value: markdown} + %MarkupContent{kind: GenLSP.Enumerations.MarkupKind.markdown(), value: markdown} end @doc """ diff --git a/expert/lib/lexical/server/state.ex b/expert/lib/lexical/server/state.ex index 8311d3b7..12177c35 100644 --- a/expert/lib/lexical/server/state.ex +++ b/expert/lib/lexical/server/state.ex @@ -24,17 +24,15 @@ defmodule Expert.State do alias Lexical.Protocol.Types.Registration alias Lexical.Protocol.Types.TextDocument alias Engine - alias Engine.Api alias Expert.CodeIntelligence alias Expert.Configuration alias Expert.Project alias Expert.Provider.Handlers alias Expert.Transport - require CodeAction.Kind require Logger - import Api.Messages + import Forge.Api.Messages defstruct configuration: nil, initialized?: false, diff --git a/engine/lib/engine/analyzer.ex b/forge/lib/forge/analyzer.ex similarity index 97% rename from engine/lib/engine/analyzer.ex rename to forge/lib/forge/analyzer.ex index 785ce7a1..4fd2ec14 100644 --- a/engine/lib/engine/analyzer.ex +++ b/forge/lib/forge/analyzer.ex @@ -1,13 +1,13 @@ -defmodule Engine.Analyzer do +defmodule Forge.Analyzer do alias Forge.Ast alias Forge.Ast.Analysis alias Forge.Ast.Analysis.Require alias Forge.Ast.Analysis.Use alias Forge.Document.Position - alias Engine.Analyzer.Aliases - alias Engine.Analyzer.Imports - alias Engine.Analyzer.Requires - alias Engine.Analyzer.Uses + alias Forge.Analyzer.Aliases + alias Forge.Analyzer.Imports + alias Forge.Analyzer.Requires + alias Forge.Analyzer.Uses require Logger diff --git a/engine/lib/engine/analyzer/aliases.ex b/forge/lib/forge/analyzer/aliases.ex similarity index 97% rename from engine/lib/engine/analyzer/aliases.ex rename to forge/lib/forge/analyzer/aliases.ex index 42636336..fbd1fe5f 100644 --- a/engine/lib/engine/analyzer/aliases.ex +++ b/forge/lib/forge/analyzer/aliases.ex @@ -1,4 +1,4 @@ -defmodule Engine.Analyzer.Aliases do +defmodule Forge.Analyzer.Aliases do alias Forge.Ast.Analysis alias Forge.Ast.Analysis.Alias alias Forge.Ast.Analysis.Scope diff --git a/engine/lib/engine/analyzer/imports.ex b/forge/lib/forge/analyzer/imports.ex similarity index 98% rename from engine/lib/engine/analyzer/imports.ex rename to forge/lib/forge/analyzer/imports.ex index f3389951..03619d50 100644 --- a/engine/lib/engine/analyzer/imports.ex +++ b/forge/lib/forge/analyzer/imports.ex @@ -1,11 +1,11 @@ -defmodule Engine.Analyzer.Imports do +defmodule Forge.Analyzer.Imports do alias Forge.Ast.Analysis alias Forge.Ast.Analysis.Import alias Forge.Ast.Analysis.Scope alias Forge.Document.Position alias Forge.Document.Range alias Forge.ProcessCache - alias Engine.Analyzer.Aliases + alias Forge.Analyzer.Aliases alias Engine.Module.Loader @spec at(Analysis.t(), Position.t()) :: [Scope.import_mfa()] diff --git a/engine/lib/engine/analyzer/requires.ex b/forge/lib/forge/analyzer/requires.ex similarity index 94% rename from engine/lib/engine/analyzer/requires.ex rename to forge/lib/forge/analyzer/requires.ex index 2f6fe9fb..45e0d555 100644 --- a/engine/lib/engine/analyzer/requires.ex +++ b/forge/lib/forge/analyzer/requires.ex @@ -1,4 +1,4 @@ -defmodule Engine.Analyzer.Requires do +defmodule Forge.Analyzer.Requires do alias Forge.Ast.Analysis alias Forge.Ast.Analysis.Require alias Forge.Ast.Analysis.Scope diff --git a/engine/lib/engine/analyzer/uses.ex b/forge/lib/forge/analyzer/uses.ex similarity index 94% rename from engine/lib/engine/analyzer/uses.ex rename to forge/lib/forge/analyzer/uses.ex index b21db05a..98cd68aa 100644 --- a/engine/lib/engine/analyzer/uses.ex +++ b/forge/lib/forge/analyzer/uses.ex @@ -1,4 +1,4 @@ -defmodule Engine.Analyzer.Uses do +defmodule Forge.Analyzer.Uses do alias Forge.Ast.Analysis alias Forge.Ast.Analysis.Scope alias Forge.Document.Position diff --git a/engine/lib/engine/code_action.ex b/forge/lib/forge/code_action.ex similarity index 93% rename from engine/lib/engine/code_action.ex rename to forge/lib/forge/code_action.ex index c2b14868..360941f2 100644 --- a/engine/lib/engine/code_action.ex +++ b/forge/lib/forge/code_action.ex @@ -1,9 +1,9 @@ -defmodule Engine.CodeAction do +defmodule Forge.CodeAction do alias Forge.Document alias Forge.Document.Changes alias Forge.Document.Range - alias Engine.CodeAction.Diagnostic - alias Engine.CodeAction.Handlers + alias Forge.CodeAction.Diagnostic + alias Forge.CodeAction.Handlers defstruct [:title, :kind, :changes, :uri] diff --git a/engine/lib/engine/code_action/diagnostic.ex b/forge/lib/forge/code_action/diagnostic.ex similarity index 91% rename from engine/lib/engine/code_action/diagnostic.ex rename to forge/lib/forge/code_action/diagnostic.ex index 8d4c3086..3a6a3d81 100644 --- a/engine/lib/engine/code_action/diagnostic.ex +++ b/forge/lib/forge/code_action/diagnostic.ex @@ -1,4 +1,4 @@ -defmodule Engine.CodeAction.Diagnostic do +defmodule Forge.CodeAction.Diagnostic do alias Forge.Document.Range defstruct [:range, :message, :source] diff --git a/engine/lib/engine/code_action/handler.ex b/forge/lib/forge/code_action/handler.ex similarity index 65% rename from engine/lib/engine/code_action/handler.ex rename to forge/lib/forge/code_action/handler.ex index d2dcbc10..610a857b 100644 --- a/engine/lib/engine/code_action/handler.ex +++ b/forge/lib/forge/code_action/handler.ex @@ -1,8 +1,8 @@ -defmodule Engine.CodeAction.Handler do +defmodule Forge.CodeAction.Handler do alias Forge.Document alias Forge.Document.Range - alias Engine.CodeAction - alias Engine.CodeAction.Diagnostic + alias Forge.CodeAction + alias Forge.CodeAction.Diagnostic @callback actions(Document.t(), Range.t(), [Diagnostic.t()]) :: [CodeAction.t()] @callback kinds() :: [CodeAction.code_action_kind()] diff --git a/engine/lib/engine/code_action/handlers/add_alias.ex b/forge/lib/forge/code_action/handlers/add_alias.ex similarity index 97% rename from engine/lib/engine/code_action/handlers/add_alias.ex rename to forge/lib/forge/code_action/handlers/add_alias.ex index 01860be4..20358283 100644 --- a/engine/lib/engine/code_action/handlers/add_alias.ex +++ b/forge/lib/forge/code_action/handlers/add_alias.ex @@ -1,4 +1,4 @@ -defmodule Engine.CodeAction.Handlers.AddAlias do +defmodule Forge.CodeAction.Handlers.AddAlias do alias Forge.Ast alias Forge.Ast.Analysis alias Forge.Ast.Analysis.Alias @@ -8,13 +8,13 @@ defmodule Engine.CodeAction.Handlers.AddAlias do alias Forge.Document.Range alias Engine.Formats - alias Engine.Analyzer - alias Engine.CodeAction - alias Engine.CodeIntelligence.Entity + alias Forge.Analyzer + alias Forge.CodeAction + alias Forge.CodeIntelligence.Entity alias Engine.CodeMod alias Engine.Modules alias Engine.Search.Fuzzy - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry alias Sourceror.Zipper @behaviour CodeAction.Handler diff --git a/engine/lib/engine/code_action/handlers/organize_aliases.ex b/forge/lib/forge/code_action/handlers/organize_aliases.ex similarity index 93% rename from engine/lib/engine/code_action/handlers/organize_aliases.ex rename to forge/lib/forge/code_action/handlers/organize_aliases.ex index db9f5896..823bb101 100644 --- a/engine/lib/engine/code_action/handlers/organize_aliases.ex +++ b/forge/lib/forge/code_action/handlers/organize_aliases.ex @@ -1,10 +1,10 @@ -defmodule Engine.CodeAction.Handlers.OrganizeAliases do +defmodule Forge.CodeAction.Handlers.OrganizeAliases do alias Forge.Ast.Analysis alias Forge.Ast.Analysis.Scope alias Forge.Document alias Forge.Document.Changes alias Forge.Document.Range - alias Engine.CodeAction + alias Forge.CodeAction alias Engine.CodeMod require Logger diff --git a/engine/lib/engine/code_action/handlers/remove_unused_alias.ex b/forge/lib/forge/code_action/handlers/remove_unused_alias.ex similarity index 98% rename from engine/lib/engine/code_action/handlers/remove_unused_alias.ex rename to forge/lib/forge/code_action/handlers/remove_unused_alias.ex index 45964d34..94a6554d 100644 --- a/engine/lib/engine/code_action/handlers/remove_unused_alias.ex +++ b/forge/lib/forge/code_action/handlers/remove_unused_alias.ex @@ -1,4 +1,4 @@ -defmodule Engine.CodeAction.Handlers.RemoveUnusedAlias do +defmodule Forge.CodeAction.Handlers.RemoveUnusedAlias do @moduledoc """ A code action that removes an unused alias @@ -28,9 +28,9 @@ defmodule Engine.CodeAction.Handlers.RemoveUnusedAlias do alias Forge.Document.Edit alias Forge.Document.Position alias Forge.Document.Range - alias Engine.Analyzer - alias Engine.CodeAction - alias Engine.CodeAction.Diagnostic + alias Forge.Analyzer + alias Forge.CodeAction + alias Forge.CodeAction.Diagnostic alias Sourceror.Zipper import Record diff --git a/engine/lib/engine/code_action/handlers/replace_remote_function.ex b/forge/lib/forge/code_action/handlers/replace_remote_function.ex similarity index 95% rename from engine/lib/engine/code_action/handlers/replace_remote_function.ex rename to forge/lib/forge/code_action/handlers/replace_remote_function.ex index 5a0eb1d1..18fcfa63 100644 --- a/engine/lib/engine/code_action/handlers/replace_remote_function.ex +++ b/forge/lib/forge/code_action/handlers/replace_remote_function.ex @@ -1,12 +1,12 @@ -defmodule Engine.CodeAction.Handlers.ReplaceRemoteFunction do +defmodule Forge.CodeAction.Handlers.ReplaceRemoteFunction do alias Forge.Ast alias Forge.Document alias Forge.Document.Changes alias Forge.Document.Edit alias Forge.Document.Range - alias Engine.CodeAction - alias Engine.CodeAction.Diagnostic + alias Forge.CodeAction + alias Forge.CodeAction.Diagnostic alias Engine.Modules alias Sourceror.Zipper @@ -60,7 +60,7 @@ defmodule Engine.CodeAction.Handlers.ReplaceRemoteFunction do |> Ast.traverse_line(line_number, [], fn %Zipper{node: {{:., _, [{:__aliases__, _, module_alias}, ^function_atom]}, _, _}} = zipper, patches -> - case Engine.Analyzer.expand_alias(module_alias, analysis, position) do + case Forge.Analyzer.expand_alias(module_alias, analysis, position) do {:ok, ^module} -> patch = Sourceror.Patch.rename_call(zipper.node, suggestion) {zipper, [patch | patches]} diff --git a/engine/lib/engine/code_action/handlers/replace_with_underscore.ex b/forge/lib/forge/code_action/handlers/replace_with_underscore.ex similarity index 94% rename from engine/lib/engine/code_action/handlers/replace_with_underscore.ex rename to forge/lib/forge/code_action/handlers/replace_with_underscore.ex index 2fdd361d..54692462 100644 --- a/engine/lib/engine/code_action/handlers/replace_with_underscore.ex +++ b/forge/lib/forge/code_action/handlers/replace_with_underscore.ex @@ -1,10 +1,10 @@ -defmodule Engine.CodeAction.Handlers.ReplaceWithUnderscore do +defmodule Forge.CodeAction.Handlers.ReplaceWithUnderscore do alias Forge.Ast alias Forge.Document alias Forge.Document.Changes alias Forge.Document.Range - alias Engine.CodeAction - alias Engine.CodeAction.Diagnostic + alias Forge.CodeAction + alias Forge.CodeAction.Diagnostic alias Sourceror.Zipper @behaviour CodeAction.Handler diff --git a/engine/lib/engine/code_intelligence/definition.ex b/forge/lib/forge/code_intelligence/definition.ex similarity index 97% rename from engine/lib/engine/code_intelligence/definition.ex rename to forge/lib/forge/code_intelligence/definition.ex index 0cb65aba..f97bbe3d 100644 --- a/engine/lib/engine/code_intelligence/definition.ex +++ b/forge/lib/forge/code_intelligence/definition.ex @@ -1,4 +1,4 @@ -defmodule Engine.CodeIntelligence.Definition do +defmodule Forge.CodeIntelligence.Definition do alias ElixirSense.Providers.Location, as: ElixirSenseLocation alias Future.Code alias Forge.Ast @@ -7,8 +7,8 @@ defmodule Engine.CodeIntelligence.Definition do alias Forge.Document.Location alias Forge.Document.Position alias Engine.Formats - alias Engine.CodeIntelligence.Entity - alias Engine.Search.Indexer.Entry + alias Forge.CodeIntelligence.Entity + alias Forge.Search.Indexer.Entry alias Engine.Search.Store alias Engine.Text diff --git a/engine/lib/engine/code_intelligence/docs.ex b/forge/lib/forge/code_intelligence/docs.ex similarity index 97% rename from engine/lib/engine/code_intelligence/docs.ex rename to forge/lib/forge/code_intelligence/docs.ex index 6fb9bad2..ae32524c 100644 --- a/engine/lib/engine/code_intelligence/docs.ex +++ b/forge/lib/forge/code_intelligence/docs.ex @@ -1,9 +1,9 @@ -defmodule Engine.CodeIntelligence.Docs do +defmodule Forge.CodeIntelligence.Docs do @moduledoc """ Utilities for fetching documentation for a compiled module. """ - alias Engine.CodeIntelligence.Docs.Entry + alias Forge.CodeIntelligence.Docs.Entry alias Engine.Modules defstruct [:module, :doc, functions_and_macros: [], callbacks: [], types: []] diff --git a/engine/lib/engine/code_intelligence/docs/entry.ex b/forge/lib/forge/code_intelligence/docs/entry.ex similarity index 96% rename from engine/lib/engine/code_intelligence/docs/entry.ex rename to forge/lib/forge/code_intelligence/docs/entry.ex index 359ae0f2..420788dc 100644 --- a/engine/lib/engine/code_intelligence/docs/entry.ex +++ b/forge/lib/forge/code_intelligence/docs/entry.ex @@ -1,4 +1,4 @@ -defmodule Engine.CodeIntelligence.Docs.Entry do +defmodule Forge.CodeIntelligence.Docs.Entry do @moduledoc """ A documentation entry for a named entity within a module. """ diff --git a/engine/lib/engine/code_intelligence/entity.ex b/forge/lib/forge/code_intelligence/entity.ex similarity index 96% rename from engine/lib/engine/code_intelligence/entity.ex rename to forge/lib/forge/code_intelligence/entity.ex index eb312a81..556ff7f2 100644 --- a/engine/lib/engine/code_intelligence/entity.ex +++ b/forge/lib/forge/code_intelligence/entity.ex @@ -1,4 +1,4 @@ -defmodule Engine.CodeIntelligence.Entity do +defmodule Forge.CodeIntelligence.Entity do alias Future.Code, as: Code alias Forge.Ast alias Forge.Ast.Analysis @@ -85,7 +85,7 @@ defmodule Engine.CodeIntelligence.Entity do when def in [:def, :defp, :defmacro, :defmacrop] -> # This case handles resolving calls that come from zero-arg definitions in # a module, like hovering in `def my_fun| do` - {:ok, module} = Engine.Analyzer.current_module(analysis, position) + {:ok, module} = Forge.Analyzer.current_module(analysis, position) {:ok, {:call, module, maybe_fun, 0}, node_range} {:ok, [{^maybe_fun, _, args} | _]} -> @@ -152,7 +152,7 @@ defmodule Engine.CodeIntelligence.Entity do with {:ok, path} <- Ast.path_at(analysis, position), arity = arity_at_position(path, position), {module, ^fun, ^arity} <- - Engine.Analyzer.resolve_local_call(analysis, position, fun, arity) do + Forge.Analyzer.resolve_local_call(analysis, position, fun, arity) do {:ok, {:call, module, fun, arity}, node_range} else _ -> @@ -222,9 +222,9 @@ defmodule Engine.CodeIntelligence.Entity do end defp maybe_prepend_ecto_schema(module_string, %Analysis{} = analysis, %Position{} = position) do - with true <- Ecto.Schema in Engine.Analyzer.uses_at(analysis, position), + with true <- Ecto.Schema in Forge.Analyzer.uses_at(analysis, position), true <- in_inline_embed?(analysis, position), - {:ok, parent_module} <- Engine.Analyzer.current_module(analysis, position) do + {:ok, parent_module} <- Forge.Analyzer.current_module(analysis, position) do parent_module |> Module.concat(module_string) |> Formats.module() @@ -254,7 +254,7 @@ defmodule Engine.CodeIntelligence.Entity do defp maybe_prepend_phoenix_scope_module(module_string, analysis, position) do with {:ok, scope_segments} <- fetch_phoenix_scope_alias_segments(analysis, position), {:ok, scope_module} <- - Engine.Analyzer.expand_alias(scope_segments, analysis, position), + Forge.Analyzer.expand_alias(scope_segments, analysis, position), cursor_module = Module.concat(scope_module, module_string), true <- phoenix_controller_module?(cursor_module) or phoenix_liveview_module?(cursor_module) do @@ -376,7 +376,7 @@ defmodule Engine.CodeIntelligence.Entity do defp expand_alias(module, analysis, %Position{} = position) when is_binary(module) do [module] |> Module.concat() - |> Engine.Analyzer.expand_alias(analysis, position) + |> Forge.Analyzer.expand_alias(analysis, position) end defp expand_alias(_, _analysis, _position), do: :error @@ -482,7 +482,7 @@ defmodule Engine.CodeIntelligence.Entity do defp fetch_module_for_imported_function(analysis, position, function_name, arity) do analysis - |> Engine.Analyzer.imports_at(position) + |> Forge.Analyzer.imports_at(position) |> Enum.find_value({:error, :not_found}, fn {imported_module, ^function_name, ^arity} -> {:ok, imported_module} @@ -493,7 +493,7 @@ defmodule Engine.CodeIntelligence.Entity do end defp fetch_module_for_local_function(analysis, position, function_name, arity) do - with {:ok, current_module} <- Engine.Analyzer.current_module(analysis, position), + with {:ok, current_module} <- Forge.Analyzer.current_module(analysis, position), true <- function_exported?(current_module, function_name, arity) do {:ok, current_module} else @@ -507,7 +507,7 @@ defmodule Engine.CodeIntelligence.Entity do end defp current_module(%Analysis{} = analysis, %Position{} = position) do - case Engine.Analyzer.current_module(analysis, position) do + case Forge.Analyzer.current_module(analysis, position) do {:ok, module} -> module _ -> nil end diff --git a/engine/lib/engine/code_intelligence/references.ex b/forge/lib/forge/code_intelligence/references.ex similarity index 93% rename from engine/lib/engine/code_intelligence/references.ex rename to forge/lib/forge/code_intelligence/references.ex index e3a6ca4c..e975f3b6 100644 --- a/engine/lib/engine/code_intelligence/references.ex +++ b/forge/lib/forge/code_intelligence/references.ex @@ -1,12 +1,12 @@ -defmodule Engine.CodeIntelligence.References do +defmodule Forge.CodeIntelligence.References do alias Forge.Ast.Analysis alias Forge.Document alias Forge.Document.Location alias Forge.Document.Position - alias Engine.Analyzer - alias Engine.CodeIntelligence.Entity - alias Engine.CodeIntelligence.Variable - alias Engine.Search.Indexer.Entry + alias Forge.Analyzer + alias Forge.CodeIntelligence.Entity + alias Forge.CodeIntelligence.Variable + alias Forge.Search.Indexer.Entry alias Engine.Search.Store alias Engine.Search.Subject diff --git a/engine/lib/engine/code_intelligence/structs.ex b/forge/lib/forge/code_intelligence/structs.ex similarity index 86% rename from engine/lib/engine/code_intelligence/structs.ex rename to forge/lib/forge/code_intelligence/structs.ex index bc2cd664..1dfc91e9 100644 --- a/engine/lib/engine/code_intelligence/structs.ex +++ b/forge/lib/forge/code_intelligence/structs.ex @@ -1,6 +1,6 @@ -defmodule Engine.CodeIntelligence.Structs do +defmodule Forge.CodeIntelligence.Structs do alias Engine.Module.Loader - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry alias Engine.Search.Store def for_project do diff --git a/engine/lib/engine/code_intelligence/symbols.ex b/forge/lib/forge/code_intelligence/symbols.ex similarity index 94% rename from engine/lib/engine/code_intelligence/symbols.ex rename to forge/lib/forge/code_intelligence/symbols.ex index f1597ba7..2f43b6c0 100644 --- a/engine/lib/engine/code_intelligence/symbols.ex +++ b/forge/lib/forge/code_intelligence/symbols.ex @@ -1,11 +1,11 @@ -defmodule Engine.CodeIntelligence.Symbols do +defmodule Forge.CodeIntelligence.Symbols do alias Forge.Document alias Forge.Document.Range - alias Engine.CodeIntelligence.Symbols + alias Forge.CodeIntelligence.Symbols alias Engine.Search - alias Engine.Search.Indexer - alias Engine.Search.Indexer.Entry - alias Engine.Search.Indexer.Extractors + alias Forge.Search.Indexer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Extractors @block_types [ :ex_unit_describe, diff --git a/engine/lib/engine/code_intelligence/symbols/document.ex b/forge/lib/forge/code_intelligence/symbols/document.ex similarity index 96% rename from engine/lib/engine/code_intelligence/symbols/document.ex rename to forge/lib/forge/code_intelligence/symbols/document.ex index 6867561c..6d65dfe0 100644 --- a/engine/lib/engine/code_intelligence/symbols/document.ex +++ b/forge/lib/forge/code_intelligence/symbols/document.ex @@ -1,7 +1,7 @@ -defmodule Engine.CodeIntelligence.Symbols.Document do +defmodule Forge.CodeIntelligence.Symbols.Document do alias Forge.Document alias Engine.Formats - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry defstruct [:name, :type, :range, :detail_range, :detail, :original_type, :subject, children: []] diff --git a/engine/lib/engine/code_intelligence/symbols/workspace.ex b/forge/lib/forge/code_intelligence/symbols/workspace.ex similarity index 92% rename from engine/lib/engine/code_intelligence/symbols/workspace.ex rename to forge/lib/forge/code_intelligence/symbols/workspace.ex index 415230b2..7eb680cd 100644 --- a/engine/lib/engine/code_intelligence/symbols/workspace.ex +++ b/forge/lib/forge/code_intelligence/symbols/workspace.ex @@ -1,4 +1,4 @@ -defmodule Engine.CodeIntelligence.Symbols.Workspace do +defmodule Forge.CodeIntelligence.Symbols.Workspace do defmodule Link do defstruct [:uri, :range, :detail_range] @@ -15,7 +15,7 @@ defmodule Engine.CodeIntelligence.Symbols.Workspace do alias Forge.Document alias Engine.Formats - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer.Entry defstruct [:name, :type, :link, container_name: nil] diff --git a/engine/lib/engine/code_intelligence/variable.ex b/forge/lib/forge/code_intelligence/variable.ex similarity index 98% rename from engine/lib/engine/code_intelligence/variable.ex rename to forge/lib/forge/code_intelligence/variable.ex index f7a5f836..4c5ae85b 100644 --- a/engine/lib/engine/code_intelligence/variable.ex +++ b/forge/lib/forge/code_intelligence/variable.ex @@ -1,9 +1,9 @@ -defmodule Engine.CodeIntelligence.Variable do +defmodule Forge.CodeIntelligence.Variable do alias Forge.Ast.Analysis alias Forge.Document.Position alias Forge.Document.Range - alias Engine.Search.Indexer - alias Engine.Search.Indexer.Entry + alias Forge.Search.Indexer + alias Forge.Search.Indexer.Entry require Logger diff --git a/engine/lib/engine/completion/candidate.ex b/forge/lib/forge/completion/candidate.ex similarity index 98% rename from engine/lib/engine/completion/candidate.ex rename to forge/lib/forge/completion/candidate.ex index 00a5199a..d7cabc8b 100644 --- a/engine/lib/engine/completion/candidate.ex +++ b/forge/lib/forge/completion/candidate.ex @@ -1,5 +1,5 @@ -defmodule Engine.Completion.Candidate do - alias Engine.Completion.Candidate.ArgumentNames +defmodule Forge.Completion.Candidate do + alias Forge.Completion.Candidate.ArgumentNames require Logger defmodule Function do diff --git a/engine/lib/engine/completion/candidate/argument_names.ex b/forge/lib/forge/completion/candidate/argument_names.ex similarity index 98% rename from engine/lib/engine/completion/candidate/argument_names.ex rename to forge/lib/forge/completion/candidate/argument_names.ex index d8d2e1b8..1fccfed5 100644 --- a/engine/lib/engine/completion/candidate/argument_names.ex +++ b/forge/lib/forge/completion/candidate/argument_names.ex @@ -1,4 +1,4 @@ -defmodule Engine.Completion.Candidate.ArgumentNames do +defmodule Forge.Completion.Candidate.ArgumentNames do @moduledoc """ Elixir sense, for whatever reason returns all the argument names when asked to do a completion on a function. This means that the arity of the function might differ from the argument names returned. Furthermore, the diff --git a/engine/lib/engine/search/fuzzy/scorer.ex b/forge/lib/forge/search/fuzzy/scorer.ex similarity index 100% rename from engine/lib/engine/search/fuzzy/scorer.ex rename to forge/lib/forge/search/fuzzy/scorer.ex diff --git a/engine/lib/engine/search/indexer/entry.ex b/forge/lib/forge/search/indexer/entry.ex similarity index 98% rename from engine/lib/engine/search/indexer/entry.ex rename to forge/lib/forge/search/indexer/entry.ex index cc87ec88..2e4ff895 100644 --- a/engine/lib/engine/search/indexer/entry.ex +++ b/forge/lib/forge/search/indexer/entry.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Indexer.Entry do +defmodule Forge.Search.Indexer.Entry do @type function_type :: :public | :private | :delegated | :usage @type protocol_type :: :implementation | :definition @@ -51,7 +51,7 @@ defmodule Engine.Search.Indexer.Entry do @type date_type :: :calendar.datetime() | integer() | DateTime.t() alias Forge.Identifier - alias Engine.Search.Indexer.Source.Block + alias Forge.Search.Indexer.Source.Block alias Forge.StructAccess use StructAccess diff --git a/engine/lib/engine/search/indexer/extractors/ecto_schema.ex b/forge/lib/forge/search/indexer/extractors/ecto_schema.ex similarity index 93% rename from engine/lib/engine/search/indexer/extractors/ecto_schema.ex rename to forge/lib/forge/search/indexer/extractors/ecto_schema.ex index 5869c605..1e14ddb1 100644 --- a/engine/lib/engine/search/indexer/extractors/ecto_schema.ex +++ b/forge/lib/forge/search/indexer/extractors/ecto_schema.ex @@ -1,10 +1,10 @@ -defmodule Engine.Search.Indexer.Extractors.EctoSchema do +defmodule Forge.Search.Indexer.Extractors.EctoSchema do alias Forge.Ast alias Forge.Document.Position - alias Engine.Analyzer - alias Engine.Search.Indexer.Entry - alias Engine.Search.Indexer.Metadata - alias Engine.Search.Indexer.Source.Reducer + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Metadata + alias Forge.Search.Indexer.Source.Reducer def extract( {:schema, meta, [{:__block__, _, [_source]} | _]} = schema_block, diff --git a/engine/lib/engine/search/indexer/extractors/ex_unit.ex b/forge/lib/forge/search/indexer/extractors/ex_unit.ex similarity index 95% rename from engine/lib/engine/search/indexer/extractors/ex_unit.ex rename to forge/lib/forge/search/indexer/extractors/ex_unit.ex index 6438bc66..a27fcd86 100644 --- a/engine/lib/engine/search/indexer/extractors/ex_unit.ex +++ b/forge/lib/forge/search/indexer/extractors/ex_unit.ex @@ -1,13 +1,13 @@ -defmodule Engine.Search.Indexer.Extractors.ExUnit do +defmodule Forge.Search.Indexer.Extractors.ExUnit do alias Forge.Ast alias Forge.Ast.Analysis alias Forge.Document.Position alias Forge.Document.Range alias Engine.Formats - alias Engine.Analyzer - alias Engine.Search.Indexer.Entry - alias Engine.Search.Indexer.Metadata - alias Engine.Search.Indexer.Source.Reducer + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Metadata + alias Forge.Search.Indexer.Source.Reducer require Logger diff --git a/engine/lib/engine/search/indexer/extractors/function_definition.ex b/forge/lib/forge/search/indexer/extractors/function_definition.ex similarity index 95% rename from engine/lib/engine/search/indexer/extractors/function_definition.ex rename to forge/lib/forge/search/indexer/extractors/function_definition.ex index fa7578b6..c7a37e02 100644 --- a/engine/lib/engine/search/indexer/extractors/function_definition.ex +++ b/forge/lib/forge/search/indexer/extractors/function_definition.ex @@ -1,9 +1,9 @@ -defmodule Engine.Search.Indexer.Extractors.FunctionDefinition do +defmodule Forge.Search.Indexer.Extractors.FunctionDefinition do alias Forge.Ast alias Forge.Ast.Analysis - alias Engine.Analyzer - alias Engine.Search.Indexer.Entry - alias Engine.Search.Indexer.Source.Reducer + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Source.Reducer alias Engine.Search.Subject @function_definitions [:def, :defp] diff --git a/engine/lib/engine/search/indexer/extractors/function_reference.ex b/forge/lib/forge/search/indexer/extractors/function_reference.ex similarity index 93% rename from engine/lib/engine/search/indexer/extractors/function_reference.ex rename to forge/lib/forge/search/indexer/extractors/function_reference.ex index 87477bda..53c9b364 100644 --- a/engine/lib/engine/search/indexer/extractors/function_reference.ex +++ b/forge/lib/forge/search/indexer/extractors/function_reference.ex @@ -1,12 +1,12 @@ -defmodule Engine.Search.Indexer.Extractors.FunctionReference do +defmodule Forge.Search.Indexer.Extractors.FunctionReference do alias Forge.Ast alias Forge.Document.Position alias Forge.Document.Range - alias Engine.Search.Indexer.Entry - alias Engine.Search.Indexer.Extractors.FunctionDefinition - alias Engine.Search.Indexer.Metadata - alias Engine.Search.Indexer.Source.Reducer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Extractors.FunctionDefinition + alias Forge.Search.Indexer.Metadata + alias Forge.Search.Indexer.Source.Reducer alias Engine.Search.Subject require Logger @@ -64,7 +64,7 @@ defmodule Engine.Search.Indexer.Extractors.FunctionReference do position = Reducer.position(reducer) {module, _, _} = - Engine.Analyzer.resolve_local_call(reducer.analysis, position, fn_name, arity) + Forge.Analyzer.resolve_local_call(reducer.analysis, position, fn_name, arity) entry = entry(reducer, end_metadata, arity_meta, module, fn_name, arity) {:ok, entry, nil} @@ -133,7 +133,7 @@ defmodule Engine.Search.Indexer.Extractors.FunctionReference do position = Reducer.position(reducer) {module, _, _} = - Engine.Analyzer.resolve_local_call(reducer.analysis, position, fn_name, arity) + Forge.Analyzer.resolve_local_call(reducer.analysis, position, fn_name, arity) entry = entry(reducer, meta, meta, [module], fn_name, args) @@ -159,7 +159,7 @@ defmodule Engine.Search.Indexer.Extractors.FunctionReference do range = get_reference_range(reducer.analysis.document, start_metadata, end_metadata, function_name) - case Engine.Analyzer.expand_alias(module, reducer.analysis, range.start) do + case Forge.Analyzer.expand_alias(module, reducer.analysis, range.start) do {:ok, module} -> mfa = Subject.mfa(module, function_name, arity) diff --git a/engine/lib/engine/search/indexer/extractors/module.ex b/forge/lib/forge/search/indexer/extractors/module.ex similarity index 96% rename from engine/lib/engine/search/indexer/extractors/module.ex rename to forge/lib/forge/search/indexer/extractors/module.ex index c0145e2a..a24f8cfb 100644 --- a/engine/lib/engine/search/indexer/extractors/module.ex +++ b/forge/lib/forge/search/indexer/extractors/module.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Indexer.Extractors.Module do +defmodule Forge.Search.Indexer.Extractors.Module do @moduledoc """ Extracts module references and definitions from AST """ @@ -8,10 +8,10 @@ defmodule Engine.Search.Indexer.Extractors.Module do alias Forge.Document.Range alias Forge.ProcessCache - alias Engine.Search.Indexer.Entry - alias Engine.Search.Indexer.Metadata - alias Engine.Search.Indexer.Source.Block - alias Engine.Search.Indexer.Source.Reducer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Metadata + alias Forge.Search.Indexer.Source.Block + alias Forge.Search.Indexer.Source.Reducer alias Engine.Search.Subject require Logger @@ -128,7 +128,7 @@ defmodule Engine.Search.Indexer.Extractors.Module do line = Sourceror.get_line(ast) pos = Position.new(reducer.analysis.document, line - 1, 1) - case Engine.Analyzer.current_module(reducer.analysis, pos) do + case Forge.Analyzer.current_module(reducer.analysis, pos) do {:ok, current_module} -> {start_line, start_col} = Metadata.position(metadata) start_pos = Position.new(reducer.analysis.document, start_line, start_col) @@ -250,7 +250,7 @@ defmodule Engine.Search.Indexer.Extractors.Module do defp resolve_alias(%Reducer{} = reducer, unresolved_alias) do position = Reducer.position(reducer) - Engine.Analyzer.expand_alias(unresolved_alias, reducer.analysis, position) + Forge.Analyzer.expand_alias(unresolved_alias, reducer.analysis, position) end defp module(%Reducer{} = reducer, maybe_module) when is_list(maybe_module) do diff --git a/engine/lib/engine/search/indexer/extractors/module_attribute.ex b/forge/lib/forge/search/indexer/extractors/module_attribute.ex similarity index 94% rename from engine/lib/engine/search/indexer/extractors/module_attribute.ex rename to forge/lib/forge/search/indexer/extractors/module_attribute.ex index 5cb4735f..fd90c7cb 100644 --- a/engine/lib/engine/search/indexer/extractors/module_attribute.ex +++ b/forge/lib/forge/search/indexer/extractors/module_attribute.ex @@ -1,13 +1,13 @@ -defmodule Engine.Search.Indexer.Extractors.ModuleAttribute do +defmodule Forge.Search.Indexer.Extractors.ModuleAttribute do @moduledoc """ Extracts module attribute definitions and references from AST """ alias Forge.Document.Position alias Forge.Document.Range - alias Engine.Analyzer - alias Engine.Search.Indexer.Entry - alias Engine.Search.Indexer.Source.Reducer + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Source.Reducer alias Engine.Search.Subject require Logger diff --git a/engine/lib/engine/search/indexer/extractors/struct_definition.ex b/forge/lib/forge/search/indexer/extractors/struct_definition.ex similarity index 80% rename from engine/lib/engine/search/indexer/extractors/struct_definition.ex rename to forge/lib/forge/search/indexer/extractors/struct_definition.ex index cfc28882..4376153c 100644 --- a/engine/lib/engine/search/indexer/extractors/struct_definition.ex +++ b/forge/lib/forge/search/indexer/extractors/struct_definition.ex @@ -1,8 +1,8 @@ -defmodule Engine.Search.Indexer.Extractors.StructDefinition do +defmodule Forge.Search.Indexer.Extractors.StructDefinition do alias Forge.Ast - alias Engine.Analyzer - alias Engine.Search.Indexer.Entry - alias Engine.Search.Indexer.Source.Reducer + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Source.Reducer def extract({:defstruct, _, [_fields]} = definition, %Reducer{} = reducer) do document = reducer.analysis.document diff --git a/engine/lib/engine/search/indexer/extractors/struct_reference.ex b/forge/lib/forge/search/indexer/extractors/struct_reference.ex similarity index 94% rename from engine/lib/engine/search/indexer/extractors/struct_reference.ex rename to forge/lib/forge/search/indexer/extractors/struct_reference.ex index 00161f4d..fe66d480 100644 --- a/engine/lib/engine/search/indexer/extractors/struct_reference.ex +++ b/forge/lib/forge/search/indexer/extractors/struct_reference.ex @@ -1,8 +1,8 @@ -defmodule Engine.Search.Indexer.Extractors.StructReference do +defmodule Forge.Search.Indexer.Extractors.StructReference do alias Forge.Ast - alias Engine.Analyzer - alias Engine.Search.Indexer.Entry - alias Engine.Search.Indexer.Source.Reducer + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Source.Reducer alias Engine.Search.Subject require Logger diff --git a/engine/lib/engine/search/indexer/extractors/variable.ex b/forge/lib/forge/search/indexer/extractors/variable.ex similarity index 97% rename from engine/lib/engine/search/indexer/extractors/variable.ex rename to forge/lib/forge/search/indexer/extractors/variable.ex index 70ca59d1..9a6519d6 100644 --- a/engine/lib/engine/search/indexer/extractors/variable.ex +++ b/forge/lib/forge/search/indexer/extractors/variable.ex @@ -1,8 +1,8 @@ -defmodule Engine.Search.Indexer.Extractors.Variable do +defmodule Forge.Search.Indexer.Extractors.Variable do alias Forge.Ast - alias Engine.Analyzer - alias Engine.Search.Indexer.Entry - alias Engine.Search.Indexer.Source.Reducer + alias Forge.Analyzer + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Source.Reducer @defs [:def, :defmacro, :defp, :defmacrop] diff --git a/engine/lib/engine/search/indexer/metadata.ex b/forge/lib/forge/search/indexer/metadata.ex similarity index 97% rename from engine/lib/engine/search/indexer/metadata.ex rename to forge/lib/forge/search/indexer/metadata.ex index 69dcc181..369144dd 100644 --- a/engine/lib/engine/search/indexer/metadata.ex +++ b/forge/lib/forge/search/indexer/metadata.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Indexer.Metadata do +defmodule Forge.Search.Indexer.Metadata do @moduledoc """ Utilities for extracting location information from AST metadata nodes. """ diff --git a/engine/lib/engine/search/indexer/module.ex b/forge/lib/forge/search/indexer/module.ex similarity index 89% rename from engine/lib/engine/search/indexer/module.ex rename to forge/lib/forge/search/indexer/module.ex index 676728cf..ac417f46 100644 --- a/engine/lib/engine/search/indexer/module.ex +++ b/forge/lib/forge/search/indexer/module.ex @@ -1,5 +1,5 @@ -defmodule Engine.Search.Indexer.Module do - alias Engine.Search.Indexer +defmodule Forge.Search.Indexer.Module do + alias Forge.Search.Indexer def index(module) do with true <- indexable?(module), diff --git a/engine/lib/engine/search/indexer/quoted.ex b/forge/lib/forge/search/indexer/quoted.ex similarity index 87% rename from engine/lib/engine/search/indexer/quoted.ex rename to forge/lib/forge/search/indexer/quoted.ex index e3752061..18e3fb37 100644 --- a/engine/lib/engine/search/indexer/quoted.ex +++ b/forge/lib/forge/search/indexer/quoted.ex @@ -1,7 +1,7 @@ -defmodule Engine.Search.Indexer.Quoted do +defmodule Forge.Search.Indexer.Quoted do alias Forge.Ast.Analysis alias Forge.ProcessCache - alias Engine.Search.Indexer.Source.Reducer + alias Forge.Search.Indexer.Source.Reducer require ProcessCache diff --git a/engine/lib/engine/search/indexer/source.ex b/forge/lib/forge/search/indexer/source.ex similarity index 82% rename from engine/lib/engine/search/indexer/source.ex rename to forge/lib/forge/search/indexer/source.ex index f04ac71c..d7338533 100644 --- a/engine/lib/engine/search/indexer/source.ex +++ b/forge/lib/forge/search/indexer/source.ex @@ -1,7 +1,7 @@ -defmodule Engine.Search.Indexer.Source do +defmodule Forge.Search.Indexer.Source do alias Forge.Ast alias Forge.Document - alias Engine.Search.Indexer + alias Forge.Search.Indexer require Logger diff --git a/engine/lib/engine/search/indexer/source/block.ex b/forge/lib/forge/search/indexer/source/block.ex similarity index 87% rename from engine/lib/engine/search/indexer/source/block.ex rename to forge/lib/forge/search/indexer/source/block.ex index b91f4a2d..e2ff9b13 100644 --- a/engine/lib/engine/search/indexer/source/block.ex +++ b/forge/lib/forge/search/indexer/source/block.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Indexer.Source.Block do +defmodule Forge.Search.Indexer.Source.Block do @moduledoc """ A struct that represents a block of source code """ diff --git a/engine/lib/engine/search/indexer/source/reducer.ex b/forge/lib/forge/search/indexer/source/reducer.ex similarity index 95% rename from engine/lib/engine/search/indexer/source/reducer.ex rename to forge/lib/forge/search/indexer/source/reducer.ex index 3b334512..e99fc235 100644 --- a/engine/lib/engine/search/indexer/source/reducer.ex +++ b/forge/lib/forge/search/indexer/source/reducer.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Indexer.Source.Reducer do +defmodule Forge.Search.Indexer.Source.Reducer do @moduledoc """ A module and struct that can reduce over elixir AST via Macro.prewalk/3 @@ -8,10 +8,10 @@ defmodule Engine.Search.Indexer.Source.Reducer do alias Forge.Ast.Analysis alias Forge.Document.Position - alias Engine.Search.Indexer.Entry - alias Engine.Search.Indexer.Extractors - alias Engine.Search.Indexer.Metadata - alias Engine.Search.Indexer.Source.Block + alias Forge.Search.Indexer.Entry + alias Forge.Search.Indexer.Extractors + alias Forge.Search.Indexer.Metadata + alias Forge.Search.Indexer.Source.Block defstruct [:analysis, :entries, :position, :blocks, :block_hierarchy, extractors: []] From 8b6101a57ad159bb5328664dd2443dd35a249c3d Mon Sep 17 00:00:00 2001 From: Mitchell Hanberg Date: Sun, 2 Feb 2025 21:04:55 -0500 Subject: [PATCH 12/12] wip --- engine/lib/engine.ex | 17 ++----- engine/lib/engine/api/proxy.ex | 10 ++-- .../lib/engine/api/proxy/buffering_state.ex | 2 +- engine/lib/engine/api/proxy/records.ex | 2 +- engine/lib/engine/application.ex | 10 ++-- engine/lib/engine/bootstrap.ex | 4 +- engine/lib/engine/build.ex | 2 +- engine/lib/engine/build/project.ex | 2 +- engine/lib/engine/build/state.ex | 2 +- engine/lib/engine/commands/reindex.ex | 6 +-- engine/lib/engine/compilation/tracer.ex | 4 +- engine/lib/engine/completion.ex | 2 +- engine/mix.exs | 2 +- expert/lib/expert.ex | 15 +++--- expert/lib/lexical/server/iex/helpers.ex | 10 ++-- .../server/provider/handlers/code_action.ex | 1 - .../provider/handlers/document_symbols.ex | 20 ++++---- expert/lib/lexical/server/state.ex | 46 +++++-------------- expert/mix.lock | 1 + forge/lib/forge.ex | 14 ++++++ forge/lib/forge/analyzer/imports.ex | 2 +- .../forge/code_action/handlers/add_alias.ex | 10 ++-- .../code_action/handlers/organize_aliases.ex | 2 +- .../handlers/replace_remote_function.ex | 2 +- .../lib/forge/code_intelligence/definition.ex | 6 +-- forge/lib/forge/code_intelligence/docs.ex | 2 +- forge/lib/forge/code_intelligence/entity.ex | 2 +- .../lib/forge/code_intelligence/references.ex | 4 +- forge/lib/forge/code_intelligence/structs.ex | 6 +-- forge/lib/forge/code_intelligence/symbols.ex | 2 +- .../code_intelligence/symbols/document.ex | 2 +- .../code_intelligence/symbols/workspace.ex | 2 +- .../lib/forge}/code_mod/aliases.ex | 4 +- .../lib/forge}/code_mod/diff.ex | 2 +- .../lib/forge}/code_mod/format.ex | 10 ++-- .../engine => forge/lib/forge}/dispatch.ex | 10 ++-- .../lib/forge}/dispatch/handler.ex | 6 +-- .../lib/forge}/dispatch/handlers/indexing.ex | 6 +-- .../lib/forge}/dispatch/pub_sub.ex | 2 +- .../lib/engine => forge/lib/forge}/formats.ex | 2 +- {engine/lib/engine => forge/lib/forge}/mix.ex | 6 +-- .../lib/forge}/module/loader.ex | 2 +- .../lib/engine => forge/lib/forge}/modules.ex | 4 +- .../lib/forge}/search/fuzzy.ex | 14 +++--- forge/lib/forge/search/fuzzy/scorer.ex | 2 +- .../lib/forge}/search/indexer.ex | 4 +- .../search/indexer/extractors/ex_unit.ex | 2 +- .../indexer/extractors/function_definition.ex | 2 +- .../indexer/extractors/function_reference.ex | 4 +- .../forge/search/indexer/extractors/module.ex | 2 +- .../indexer/extractors/module_attribute.ex | 2 +- .../indexer/extractors/struct_reference.ex | 2 +- .../lib/forge}/search/store.ex | 8 ++-- .../lib/forge}/search/store/backend.ex | 2 +- .../lib/forge}/search/store/backends/ets.ex | 12 ++--- .../search/store/backends/ets/schema.ex | 4 +- .../store/backends/ets/schemas/legacy_v0.ex | 4 +- .../search/store/backends/ets/schemas/v1.ex | 4 +- .../search/store/backends/ets/schemas/v2.ex | 4 +- .../search/store/backends/ets/schemas/v3.ex | 4 +- .../forge}/search/store/backends/ets/state.ex | 8 ++-- .../forge}/search/store/backends/ets/wal.ex | 2 +- .../lib/forge}/search/store/state.ex | 6 +-- .../lib/forge}/search/subject.ex | 4 +- .../lib/engine => forge/lib/forge}/text.ex | 2 +- forge/mix.exs | 4 +- forge/mix.lock | 1 + 67 files changed, 176 insertions(+), 195 deletions(-) rename {engine/lib/engine => forge/lib/forge}/code_mod/aliases.ex (99%) rename {engine/lib/engine => forge/lib/forge}/code_mod/diff.ex (99%) rename {engine/lib/engine => forge/lib/forge}/code_mod/format.ex (96%) rename {engine/lib/engine => forge/lib/forge}/dispatch.ex (89%) rename {engine/lib/engine => forge/lib/forge}/dispatch/handler.ex (94%) rename {engine/lib/engine => forge/lib/forge}/dispatch/handlers/indexing.ex (87%) rename {engine/lib/engine => forge/lib/forge}/dispatch/pub_sub.ex (98%) rename {engine/lib/engine => forge/lib/forge}/formats.ex (98%) rename {engine/lib/engine => forge/lib/forge}/mix.ex (92%) rename {engine/lib/engine => forge/lib/forge}/module/loader.ex (96%) rename {engine/lib/engine => forge/lib/forge}/modules.ex (99%) rename {engine/lib/engine => forge/lib/forge}/search/fuzzy.ex (97%) rename {engine/lib/engine => forge/lib/forge}/search/indexer.ex (97%) rename {engine/lib/engine => forge/lib/forge}/search/store.ex (97%) rename {engine/lib/engine => forge/lib/forge}/search/store/backend.ex (98%) rename {engine/lib/engine => forge/lib/forge}/search/store/backends/ets.ex (95%) rename {engine/lib/engine => forge/lib/forge}/search/store/backends/ets/schema.ex (98%) rename {engine/lib/engine => forge/lib/forge}/search/store/backends/ets/schemas/legacy_v0.ex (74%) rename {engine/lib/engine => forge/lib/forge}/search/store/backends/ets/schemas/v1.ex (94%) rename {engine/lib/engine => forge/lib/forge}/search/store/backends/ets/schemas/v2.ex (93%) rename {engine/lib/engine => forge/lib/forge}/search/store/backends/ets/schemas/v3.ex (94%) rename {engine/lib/engine => forge/lib/forge}/search/store/backends/ets/state.ex (97%) rename {engine/lib/engine => forge/lib/forge}/search/store/backends/ets/wal.ex (99%) rename {engine/lib/engine => forge/lib/forge}/search/store/state.ex (98%) rename {engine/lib/engine => forge/lib/forge}/search/subject.ex (83%) rename {engine/lib/engine => forge/lib/forge}/text.ex (90%) diff --git a/engine/lib/engine.ex b/engine/lib/engine.ex index 2f471fe0..cb6a18ab 100644 --- a/engine/lib/engine.ex +++ b/engine/lib/engine.ex @@ -46,13 +46,13 @@ defmodule Engine do defdelegate references(analysis, position, include_definitions?), to: CodeIntelligence.References - defdelegate modules_with_prefix(prefix), to: Engine.Modules, as: :with_prefix + defdelegate modules_with_prefix(prefix), to: Forge.Modules, as: :with_prefix - defdelegate modules_with_prefix(prefix, predicate), to: Engine.Modules, as: :with_prefix + defdelegate modules_with_prefix(prefix, predicate), to: Forge.Modules, as: :with_prefix defdelegate docs(module, opts \\ []), to: CodeIntelligence.Docs, as: :for_module - defdelegate register_listener(listener_pid, message_types), to: Engine.Dispatch + defdelegate register_listener(listener_pid, message_types), to: Forge.Dispatch defdelegate resolve_entity(analysis, position), to: CodeIntelligence.Entity, as: :resolve @@ -79,17 +79,6 @@ defmodule Engine do :global.trans({lock_type, self()}, func, [Node.self()]) end - def project_node? do - !!:persistent_term.get({__MODULE__, :project}, false) - end - - def get_project do - :persistent_term.get({__MODULE__, :project}, nil) - end - - def set_project(%Project{} = project) do - :persistent_term.put({__MODULE__, :project}, project) - end defdelegate stop(project), to: ProjectNode diff --git a/engine/lib/engine/api/proxy.ex b/engine/lib/engine/api/proxy.ex index 6cebd5f5..ad144587 100644 --- a/engine/lib/engine/api/proxy.ex +++ b/engine/lib/engine/api/proxy.ex @@ -38,7 +38,7 @@ defmodule Engine.Api.Proxy do alias Engine.Api.Proxy.DrainingState alias Engine.Api.Proxy.ProxyingState alias Engine.Api.Proxy.Records - alias Engine.CodeMod + alias Forge.CodeMod alias Engine.Commands import Messages @@ -63,23 +63,23 @@ defmodule Engine.Api.Proxy do # proxied functions def broadcast(percent_progress() = message) do - Engine.Dispatch.broadcast(message) + Forge.Dispatch.broadcast(message) end def broadcast(message) do - mfa = to_mfa(Engine.Dispatch.broadcast(message)) + mfa = to_mfa(Forge.Dispatch.broadcast(message)) :gen_statem.call(__MODULE__, buffer(contents: mfa)) end def schedule_compile(force? \\ false) do - project = Engine.get_project() + project = Forge.get_project() mfa = to_mfa(Engine.Build.schedule_compile(project, force?)) :gen_statem.call(__MODULE__, buffer(contents: mfa)) end def compile_document(document) do - project = Engine.get_project() + project = Forge.get_project() mfa = to_mfa(Engine.Build.compile_document(project, document)) diff --git a/engine/lib/engine/api/proxy/buffering_state.ex b/engine/lib/engine/api/proxy/buffering_state.ex index 8abf051a..2189d186 100644 --- a/engine/lib/engine/api/proxy/buffering_state.ex +++ b/engine/lib/engine/api/proxy/buffering_state.ex @@ -23,7 +23,7 @@ defmodule Engine.Api.Proxy.BufferingState do state.buffer |> Enum.reverse() |> Enum.split_with(fn value -> - match?(mfa(module: Engine.Dispatch, function: :broadcast), value) + match?(mfa(module: Forge.Dispatch, function: :broadcast), value) end) {project_compile, document_compiles, reindex} = collapse_commands(commands) diff --git a/engine/lib/engine/api/proxy/records.ex b/engine/lib/engine/api/proxy/records.ex index 0e53a2fd..1a9d344c 100644 --- a/engine/lib/engine/api/proxy/records.ex +++ b/engine/lib/engine/api/proxy/records.ex @@ -1,5 +1,5 @@ defmodule Engine.Api.Proxy.Records do - alias Engine.Formats + alias Forge.Formats import Record diff --git a/engine/lib/engine/application.ex b/engine/lib/engine/application.ex index 5ba99be4..3c84beff 100644 --- a/engine/lib/engine/application.ex +++ b/engine/lib/engine/application.ex @@ -7,17 +7,17 @@ defmodule Engine.Application do @impl true def start(_type, _args) do children = - if Engine.project_node?() do + if Forge.project_node?() do [ Engine.Api.Proxy, Engine.Commands.Reindex, - Engine.Module.Loader, - {Engine.Dispatch, progress: true}, + Forge.Module.Loader, + {Forge.Dispatch, progress: true}, Engine.ModuleMappings, Engine.Build, Engine.Build.CaptureServer, - Engine.Search.Store.Backends.Ets, - {Engine.Search.Store, + Forge.Search.Store.Backends.Ets, + {Forge.Search.Store, [ &Forge.Search.Indexer.create_index/1, &Forge.Search.Indexer.update_index/2 diff --git a/engine/lib/engine/bootstrap.ex b/engine/lib/engine/bootstrap.ex index bd005ca6..c0aa36af 100644 --- a/engine/lib/engine/bootstrap.ex +++ b/engine/lib/engine/bootstrap.ex @@ -24,7 +24,7 @@ defmodule Engine.Bootstrap do {:ok, _} <- Application.ensure_all_started(:mix), {:ok, _} <- Application.ensure_all_started(:logger) do project = maybe_load_mix_exs(project) - Engine.set_project(project) + Forge.set_project(project) Mix.env(:test) ExUnit.start() start_logger(project) @@ -76,7 +76,7 @@ defmodule Engine.Bootstrap do # app is an umbrella (umbrealla? returns false when started in a subapp) # to no avail. This was the only thing that consistently worked {:ok, configured_root} = - Engine.Mix.in_project(project, fn _ -> + Forge.Mix.in_project(project, fn _ -> Mix.Project.config() |> Keyword.get(:config_path) |> Path.dirname() diff --git a/engine/lib/engine/build.ex b/engine/lib/engine/build.ex index 32ab3e70..8fd8dfdc 100644 --- a/engine/lib/engine/build.ex +++ b/engine/lib/engine/build.ex @@ -57,7 +57,7 @@ defmodule Engine.Build do @impl GenServer def init([]) do - state = State.new(Engine.get_project()) + state = State.new(Forge.get_project()) with :ok <- State.set_compiler_options() do {:ok, state, {:continue, :ensure_build_directory}} diff --git a/engine/lib/engine/build/project.ex b/engine/lib/engine/build/project.ex index 81b96ea8..3a9f8ceb 100644 --- a/engine/lib/engine/build/project.ex +++ b/engine/lib/engine/build/project.ex @@ -9,7 +9,7 @@ defmodule Engine.Build.Project do require Logger def compile(%Project{} = project, initial?) do - Engine.Mix.in_project(fn _ -> + Forge.Mix.in_project(fn _ -> Mix.Task.clear() prepare_for_project_build(initial?) diff --git a/engine/lib/engine/build/state.ex b/engine/lib/engine/build/state.ex index 76f95e8f..1a761418 100644 --- a/engine/lib/engine/build/state.ex +++ b/engine/lib/engine/build/state.ex @@ -130,7 +130,7 @@ defmodule Engine.Build.State do Engine.broadcast(file_compile_requested(uri: document.uri)) safe_compile_func = fn -> - Engine.Mix.in_project(fn _ -> Build.Document.compile(document) end) + Forge.Mix.in_project(fn _ -> Build.Document.compile(document) end) end {elapsed_us, result} = :timer.tc(fn -> safe_compile_func.() end) diff --git a/engine/lib/engine/commands/reindex.ex b/engine/lib/engine/commands/reindex.ex index 65e860ec..b42cb659 100644 --- a/engine/lib/engine/commands/reindex.ex +++ b/engine/lib/engine/commands/reindex.ex @@ -3,7 +3,7 @@ defmodule Engine.Commands.Reindex do alias Forge.Ast.Analysis alias Forge.Document alias Forge.ProcessCache - alias Engine.Search + alias Forge.Search alias Forge.Search.Indexer require Logger @@ -73,7 +73,7 @@ defmodule Engine.Commands.Reindex do alias Forge.Document alias Forge.Project - alias Engine.Search + alias Forge.Search use GenServer import Forge.Api.Messages @@ -88,7 +88,7 @@ defmodule Engine.Commands.Reindex do end def perform do - perform(Engine.get_project()) + perform(Forge.get_project()) end def perform(%Project{} = project) do diff --git a/engine/lib/engine/compilation/tracer.ex b/engine/lib/engine/compilation/tracer.ex index 45ac9582..cfc64c9c 100644 --- a/engine/lib/engine/compilation/tracer.ex +++ b/engine/lib/engine/compilation/tracer.ex @@ -1,6 +1,6 @@ defmodule Engine.Compilation.Tracer do alias Engine.Build - alias Engine.Module.Loader + alias Forge.Module.Loader import Forge.Api.Messages @@ -74,7 +74,7 @@ defmodule Engine.Compilation.Tracer do message = "compiling: " <> Path.join([base_dir, "...", file_name]) - label = Build.State.building_label(Engine.get_project()) + label = Build.State.building_label(Forge.get_project()) project_progress(label: label, message: message) end end diff --git a/engine/lib/engine/completion.ex b/engine/lib/engine/completion.ex index 41afd67c..818a33aa 100644 --- a/engine/lib/engine/completion.ex +++ b/engine/lib/engine/completion.ex @@ -4,7 +4,7 @@ defmodule Engine.Completion do alias Forge.Document alias Forge.Document.Position - alias Engine.CodeMod.Format + alias Forge.CodeMod.Format alias Forge.Completion.Candidate import Document.Line diff --git a/engine/mix.exs b/engine/mix.exs index 7268b5aa..94242c79 100644 --- a/engine/mix.exs +++ b/engine/mix.exs @@ -30,7 +30,7 @@ defmodule Engine.MixProject do # {:gen_lsp, "~> 0.10"}, {:gen_lsp, github: "elixir-tools/gen_lsp", branch: "change-schematic-function", override: true}, - {:namespace, path: "../namespace", only: [:dev, :prod], runtime: false} + {:namespace, path: "../namespace", runtime: false} ] end end diff --git a/expert/lib/expert.ex b/expert/lib/expert.ex index 301f5a33..707db4ff 100644 --- a/expert/lib/expert.ex +++ b/expert/lib/expert.ex @@ -11,10 +11,9 @@ defmodule Expert do alias GenLSP.Structures.InitializeParams alias GenLSP.Requests.Initialize - require Logger - require Expert.Runtime + alias Expert.State - alias Expert.Runtime + require Logger def start_link(args) do {args, opts} = @@ -31,7 +30,8 @@ defmodule Expert do assign(lsp, dynamic_supervisor: dynamic_supervisor, exit_code: 1, - client_capabilities: nil + client_capabilities: nil, + state: State.new() )} end @@ -43,9 +43,11 @@ defmodule Expert do workspace_folders: workspace_folders, capabilities: caps } - }, + } = request, lsp ) do + state = Expert.State.initialize(Expert.State.new(), request) + {:reply, %InitializeResult{ capabilities: %ServerCapabilities{ @@ -83,7 +85,8 @@ defmodule Expert do assign(lsp, root_uri: root_uri, workspace_folders: workspace_folders, - client_capabilities: caps + client_capabilities: caps, + state: state )} end diff --git a/expert/lib/lexical/server/iex/helpers.ex b/expert/lib/lexical/server/iex/helpers.ex index 1400446d..15462d3b 100644 --- a/expert/lib/lexical/server/iex/helpers.ex +++ b/expert/lib/lexical/server/iex/helpers.ex @@ -5,7 +5,7 @@ defmodule Expert.IEx.Helpers do alias Forge.Project alias Lexical.Protocol.Types.Completion alias Engine - alias Engine.Search + alias Forge.Search alias Expert.CodeIntelligence defmacro __using__(_) do @@ -13,11 +13,11 @@ defmodule Expert.IEx.Helpers do alias Forge.Document alias Forge.Document.Position alias Engine - alias Engine.Search + alias Forge.Search import unquote(__MODULE__) - Engine.Module.Loader.start_link(nil) - Engine.Dispatch.start_link([]) + Forge.Module.Loader.start_link(nil) + Forge.Dispatch.start_link([]) end end @@ -56,7 +56,7 @@ defmodule Expert.IEx.Helpers do def search_store(project) do project = ensure_project(project) - Engine.set_project(project) + Forge.set_project(project) Search.Store.start_link( project, diff --git a/expert/lib/lexical/server/provider/handlers/code_action.ex b/expert/lib/lexical/server/provider/handlers/code_action.ex index 1198290c..5b56b067 100644 --- a/expert/lib/lexical/server/provider/handlers/code_action.ex +++ b/expert/lib/lexical/server/provider/handlers/code_action.ex @@ -1,5 +1,4 @@ defmodule Expert.Provider.Handlers.CodeAction do - alias Lexical.Protocol.Requests alias GenLSP.Requests.TextDocumentCodeAction alias GenLSP.Structures.Diagnostic alias GenLSP.Structures.WorkspaceEdit diff --git a/expert/lib/lexical/server/provider/handlers/document_symbols.ex b/expert/lib/lexical/server/provider/handlers/document_symbols.ex index 01c90ec3..af0946db 100644 --- a/expert/lib/lexical/server/provider/handlers/document_symbols.ex +++ b/expert/lib/lexical/server/provider/handlers/document_symbols.ex @@ -1,25 +1,21 @@ defmodule Expert.Provider.Handlers.DocumentSymbols do alias Forge.Document - alias Lexical.Protocol.Requests.DocumentSymbols - alias Lexical.Protocol.Responses - alias Lexical.Protocol.Types.Document.Symbol - alias Lexical.Protocol.Types.Symbol.Kind, as: SymbolKind + alias GenLSP.Requests.TextDocumentDocumentSymbol alias Engine.Api - alias Forge.CodeIntelligence.Symbols + # alias Forge.CodeIntelligence.Symbols alias Expert.Configuration + alias GenLSP.Structures.DocumentSymbol - def handle(%DocumentSymbols{} = request, %Configuration{} = config) do + def handle(%TextDocumentDocumentSymbol{} = request, %Configuration{} = config) do symbols = config.project |> Api.document_symbols(request.document) |> Enum.map(&to_response(&1, request.document)) - response = Responses.DocumentSymbols.new(request.id, symbols) - - {:reply, response} + {:reply, symbols} end - def to_response(%Symbols.Document{} = root, %Document{} = document) do + def to_response(%DocumentSymbol{} = root, %Document{} = document) do children = case root.children do list when is_list(list) -> @@ -29,14 +25,14 @@ defmodule Expert.Provider.Handlers.DocumentSymbols do nil end - Symbol.new( + %DocumentSymbol{ children: children, detail: root.detail, kind: to_kind(root.type), name: root.name, range: root.range, selection_range: root.detail_range - ) + } end defp to_kind(:struct), do: :struct diff --git a/expert/lib/lexical/server/state.ex b/expert/lib/lexical/server/state.ex index 12177c35..20b7ce46 100644 --- a/expert/lib/lexical/server/state.ex +++ b/expert/lib/lexical/server/state.ex @@ -1,34 +1,10 @@ defmodule Expert.State do alias Forge.Document - alias Lexical.Protocol.Id - alias Lexical.Protocol.Notifications - alias Lexical.Protocol.Notifications.DidChange - alias Lexical.Protocol.Notifications.DidChangeConfiguration - alias Lexical.Protocol.Notifications.DidClose - alias Lexical.Protocol.Notifications.DidOpen - alias Lexical.Protocol.Notifications.DidSave - alias Lexical.Protocol.Notifications.Exit - alias Lexical.Protocol.Notifications.Initialized - alias Lexical.Protocol.Requests.Initialize - alias Lexical.Protocol.Requests.RegisterCapability - alias Lexical.Protocol.Requests.Shutdown - alias Lexical.Protocol.Responses - alias Lexical.Protocol.Types - alias Lexical.Protocol.Types.CodeAction - alias Lexical.Protocol.Types.CodeLens - alias Lexical.Protocol.Types.Completion - alias Lexical.Protocol.Types.DidChangeWatchedFiles - alias Lexical.Protocol.Types.ExecuteCommand - alias Lexical.Protocol.Types.FileEvent - alias Lexical.Protocol.Types.FileSystemWatcher - alias Lexical.Protocol.Types.Registration - alias Lexical.Protocol.Types.TextDocument - alias Engine alias Expert.CodeIntelligence alias Expert.Configuration alias Expert.Project - alias Expert.Provider.Handlers - alias Expert.Transport + # alias Expert.Provider.Handlers + alias GenLSP.Requests.Initialize require Logger @@ -48,24 +24,24 @@ defmodule Expert.State do %__MODULE__{} end - def initialize(%__MODULE__{initialized?: false} = state, %Initialize{ - lsp: %Initialize.LSP{} = event - }) do + def initialize(%__MODULE__{initialized?: false} = state, %Initialize{params: params}) do client_name = - case event.client_info do + case params.client_info do %{name: name} -> name _ -> nil end - config = Configuration.new(event.root_uri, event.capabilities, client_name) + config = Configuration.new(params.root_uri, params.capabilities, client_name) new_state = %__MODULE__{state | configuration: config, initialized?: true} Logger.info("Starting project at uri #{config.project.root_uri}") - event.id - |> initialize_result() - |> Transport.write() + # we do this in the server process + # event.id + # |> initialize_result() + # |> Transport.write() - Transport.write(registrations()) + # same here + # Transport.write(registrations()) Project.Supervisor.start(config.project) {:ok, new_state} diff --git a/expert/mix.lock b/expert/mix.lock index 121b2596..502bca55 100644 --- a/expert/mix.lock +++ b/expert/mix.lock @@ -1,5 +1,6 @@ %{ "burrito": {:hex, :burrito, "1.2.0", "88f973469edcb96bd984498fb639d3fc4dbf01b52baab072b40229f03a396789", [:mix], [{:jason, "~> 1.2", [hex: :jason, repo: "hexpm", optional: false]}, {:req, ">= 0.4.0", [hex: :req, repo: "hexpm", optional: false]}, {:typed_struct, "~> 0.2.0 or ~> 0.3.0", [hex: :typed_struct, repo: "hexpm", optional: false]}], "hexpm", "7e22158023c6558de615795ab135d27f0cbd9a0602834e3e474fe41b448afba9"}, + "elixir_sense": {:git, "https://github.com/elixir-lsp/elixir_sense.git", "706c498be371882366151b588e5cd13c9c08404c", []}, "finch": {:hex, :finch, "0.19.0", "c644641491ea854fc5c1bbaef36bfc764e3f08e7185e1f084e35e0672241b76d", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.6.2 or ~> 1.7", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 1.1", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "fc5324ce209125d1e2fa0fcd2634601c52a787aff1cd33ee833664a5af4ea2b6"}, "gen_lsp": {:git, "https://github.com/elixir-tools/gen_lsp.git", "f63f284289ef61b678ab6bd2cbcf3a6ba3d9fcdd", [branch: "change-schematic-function"]}, "hpax": {:hex, :hpax, "1.0.0", "28dcf54509fe2152a3d040e4e3df5b265dcb6cb532029ecbacf4ce52caea3fd2", [:mix], [], "hexpm", "7f1314731d711e2ca5fdc7fd361296593fc2542570b3105595bb0bc6d0fad601"}, diff --git a/forge/lib/forge.ex b/forge/lib/forge.ex index a31eec1c..48baf075 100644 --- a/forge/lib/forge.ex +++ b/forge/lib/forge.ex @@ -4,4 +4,18 @@ defmodule Forge do @typedoc "A string representation of a path on the filesystem" @type path :: String.t() + + alias Forge.Project + + def project_node? do + !!:persistent_term.get({__MODULE__, :project}, false) + end + + def get_project do + :persistent_term.get({__MODULE__, :project}, nil) + end + + def set_project(%Project{} = project) do + :persistent_term.put({__MODULE__, :project}, project) + end end diff --git a/forge/lib/forge/analyzer/imports.ex b/forge/lib/forge/analyzer/imports.ex index 03619d50..c0ab6959 100644 --- a/forge/lib/forge/analyzer/imports.ex +++ b/forge/lib/forge/analyzer/imports.ex @@ -6,7 +6,7 @@ defmodule Forge.Analyzer.Imports do alias Forge.Document.Range alias Forge.ProcessCache alias Forge.Analyzer.Aliases - alias Engine.Module.Loader + alias Forge.Module.Loader @spec at(Analysis.t(), Position.t()) :: [Scope.import_mfa()] def at(%Analysis{} = analysis, %Position{} = position) do diff --git a/forge/lib/forge/code_action/handlers/add_alias.ex b/forge/lib/forge/code_action/handlers/add_alias.ex index 20358283..dc7367e7 100644 --- a/forge/lib/forge/code_action/handlers/add_alias.ex +++ b/forge/lib/forge/code_action/handlers/add_alias.ex @@ -6,14 +6,14 @@ defmodule Forge.CodeAction.Handlers.AddAlias do alias Forge.Document.Changes alias Forge.Document.Position alias Forge.Document.Range - alias Engine.Formats + alias Forge.Formats alias Forge.Analyzer alias Forge.CodeAction alias Forge.CodeIntelligence.Entity - alias Engine.CodeMod - alias Engine.Modules - alias Engine.Search.Fuzzy + alias Forge.CodeMod + alias Forge.Modules + alias Forge.Search.Fuzzy alias Forge.Search.Indexer.Entry alias Sourceror.Zipper @@ -166,7 +166,7 @@ defmodule Forge.CodeAction.Handlers.AddAlias do {:elixir, split} = Ast.Module.safe_split(module) alias_as = List.last(split) subject_module = module - Engine.Module.Loader.ensure_loaded(subject_module) + Forge.Module.Loader.ensure_loaded(subject_module) protocol_or_implementation? = function_exported?(module, :__impl__, 1) diff --git a/forge/lib/forge/code_action/handlers/organize_aliases.ex b/forge/lib/forge/code_action/handlers/organize_aliases.ex index 823bb101..579dd386 100644 --- a/forge/lib/forge/code_action/handlers/organize_aliases.ex +++ b/forge/lib/forge/code_action/handlers/organize_aliases.ex @@ -5,7 +5,7 @@ defmodule Forge.CodeAction.Handlers.OrganizeAliases do alias Forge.Document.Changes alias Forge.Document.Range alias Forge.CodeAction - alias Engine.CodeMod + alias Forge.CodeMod require Logger diff --git a/forge/lib/forge/code_action/handlers/replace_remote_function.ex b/forge/lib/forge/code_action/handlers/replace_remote_function.ex index 18fcfa63..356a6879 100644 --- a/forge/lib/forge/code_action/handlers/replace_remote_function.ex +++ b/forge/lib/forge/code_action/handlers/replace_remote_function.ex @@ -7,7 +7,7 @@ defmodule Forge.CodeAction.Handlers.ReplaceRemoteFunction do alias Forge.CodeAction alias Forge.CodeAction.Diagnostic - alias Engine.Modules + alias Forge.Modules alias Sourceror.Zipper @behaviour CodeAction.Handler diff --git a/forge/lib/forge/code_intelligence/definition.ex b/forge/lib/forge/code_intelligence/definition.ex index f97bbe3d..59e1d3cc 100644 --- a/forge/lib/forge/code_intelligence/definition.ex +++ b/forge/lib/forge/code_intelligence/definition.ex @@ -6,11 +6,11 @@ defmodule Forge.CodeIntelligence.Definition do alias Forge.Document alias Forge.Document.Location alias Forge.Document.Position - alias Engine.Formats + alias Forge.Formats alias Forge.CodeIntelligence.Entity alias Forge.Search.Indexer.Entry - alias Engine.Search.Store - alias Engine.Text + alias Forge.Search.Store + alias Forge.Text require Logger diff --git a/forge/lib/forge/code_intelligence/docs.ex b/forge/lib/forge/code_intelligence/docs.ex index ae32524c..208d091d 100644 --- a/forge/lib/forge/code_intelligence/docs.ex +++ b/forge/lib/forge/code_intelligence/docs.ex @@ -4,7 +4,7 @@ defmodule Forge.CodeIntelligence.Docs do """ alias Forge.CodeIntelligence.Docs.Entry - alias Engine.Modules + alias Forge.Modules defstruct [:module, :doc, functions_and_macros: [], callbacks: [], types: []] diff --git a/forge/lib/forge/code_intelligence/entity.ex b/forge/lib/forge/code_intelligence/entity.ex index 556ff7f2..9be5d3af 100644 --- a/forge/lib/forge/code_intelligence/entity.ex +++ b/forge/lib/forge/code_intelligence/entity.ex @@ -5,7 +5,7 @@ defmodule Forge.CodeIntelligence.Entity do alias Forge.Document alias Forge.Document.Position alias Forge.Document.Range - alias Engine.Formats + alias Forge.Formats alias Sourceror.Zipper diff --git a/forge/lib/forge/code_intelligence/references.ex b/forge/lib/forge/code_intelligence/references.ex index e975f3b6..6c034dfe 100644 --- a/forge/lib/forge/code_intelligence/references.ex +++ b/forge/lib/forge/code_intelligence/references.ex @@ -7,8 +7,8 @@ defmodule Forge.CodeIntelligence.References do alias Forge.CodeIntelligence.Entity alias Forge.CodeIntelligence.Variable alias Forge.Search.Indexer.Entry - alias Engine.Search.Store - alias Engine.Search.Subject + alias Forge.Search.Store + alias Forge.Search.Subject require Logger diff --git a/forge/lib/forge/code_intelligence/structs.ex b/forge/lib/forge/code_intelligence/structs.ex index 1dfc91e9..d323e792 100644 --- a/forge/lib/forge/code_intelligence/structs.ex +++ b/forge/lib/forge/code_intelligence/structs.ex @@ -1,13 +1,13 @@ defmodule Forge.CodeIntelligence.Structs do - alias Engine.Module.Loader + alias Forge.Module.Loader alias Forge.Search.Indexer.Entry - alias Engine.Search.Store + alias Forge.Search.Store def for_project do if Mix.Project.get() do {:ok, structs_from_index()} else - Engine.Mix.in_project(fn _ -> structs_from_index() end) + Forge.Mix.in_project(fn _ -> structs_from_index() end) end end diff --git a/forge/lib/forge/code_intelligence/symbols.ex b/forge/lib/forge/code_intelligence/symbols.ex index 2f43b6c0..db703d7b 100644 --- a/forge/lib/forge/code_intelligence/symbols.ex +++ b/forge/lib/forge/code_intelligence/symbols.ex @@ -2,7 +2,7 @@ defmodule Forge.CodeIntelligence.Symbols do alias Forge.Document alias Forge.Document.Range alias Forge.CodeIntelligence.Symbols - alias Engine.Search + alias Forge.Search alias Forge.Search.Indexer alias Forge.Search.Indexer.Entry alias Forge.Search.Indexer.Extractors diff --git a/forge/lib/forge/code_intelligence/symbols/document.ex b/forge/lib/forge/code_intelligence/symbols/document.ex index 6d65dfe0..5bf9b53f 100644 --- a/forge/lib/forge/code_intelligence/symbols/document.ex +++ b/forge/lib/forge/code_intelligence/symbols/document.ex @@ -1,6 +1,6 @@ defmodule Forge.CodeIntelligence.Symbols.Document do alias Forge.Document - alias Engine.Formats + alias Forge.Formats alias Forge.Search.Indexer.Entry defstruct [:name, :type, :range, :detail_range, :detail, :original_type, :subject, children: []] diff --git a/forge/lib/forge/code_intelligence/symbols/workspace.ex b/forge/lib/forge/code_intelligence/symbols/workspace.ex index 7eb680cd..ec86fdf5 100644 --- a/forge/lib/forge/code_intelligence/symbols/workspace.ex +++ b/forge/lib/forge/code_intelligence/symbols/workspace.ex @@ -14,7 +14,7 @@ defmodule Forge.CodeIntelligence.Symbols.Workspace do end alias Forge.Document - alias Engine.Formats + alias Forge.Formats alias Forge.Search.Indexer.Entry defstruct [:name, :type, :link, container_name: nil] diff --git a/engine/lib/engine/code_mod/aliases.ex b/forge/lib/forge/code_mod/aliases.ex similarity index 99% rename from engine/lib/engine/code_mod/aliases.ex rename to forge/lib/forge/code_mod/aliases.ex index 5153eb62..cd623508 100644 --- a/engine/lib/engine/code_mod/aliases.ex +++ b/forge/lib/forge/code_mod/aliases.ex @@ -1,4 +1,4 @@ -defmodule Engine.CodeMod.Aliases do +defmodule Forge.CodeMod.Aliases do alias Forge.Ast alias Forge.Ast.Analysis alias Forge.Ast.Analysis.Alias @@ -234,7 +234,7 @@ defmodule Engine.CodeMod.Aliases do end defp maybe_move_cursor_to_token_start(%Position{} = position, %Analysis{} = analysis) do - project = Engine.get_project() + project = Forge.get_project() with {:ok, env} <- Ast.Env.new(project, analysis, position), false <- String.last(env.prefix) in [" ", ""] do diff --git a/engine/lib/engine/code_mod/diff.ex b/forge/lib/forge/code_mod/diff.ex similarity index 99% rename from engine/lib/engine/code_mod/diff.ex rename to forge/lib/forge/code_mod/diff.ex index 3524fa4f..7e63e4a0 100644 --- a/engine/lib/engine/code_mod/diff.ex +++ b/forge/lib/forge/code_mod/diff.ex @@ -1,4 +1,4 @@ -defmodule Engine.CodeMod.Diff do +defmodule Forge.CodeMod.Diff do alias Forge.CodeUnit alias Forge.Document alias Forge.Document.Edit diff --git a/engine/lib/engine/code_mod/format.ex b/forge/lib/forge/code_mod/format.ex similarity index 96% rename from engine/lib/engine/code_mod/format.ex rename to forge/lib/forge/code_mod/format.ex index b7e88e8c..09a65e87 100644 --- a/engine/lib/engine/code_mod/format.ex +++ b/forge/lib/forge/code_mod/format.ex @@ -1,10 +1,10 @@ -defmodule Engine.CodeMod.Format do +defmodule Forge.CodeMod.Format do alias Forge.Document alias Forge.Document.Changes alias Forge.Project alias Engine.Build - alias Engine.CodeMod.Diff + alias Forge.CodeMod.Diff require Logger @@ -97,7 +97,7 @@ defmodule Engine.CodeMod.Format do @spec edits(Document.t()) :: {:ok, Changes.t()} | {:error, any} def edits(%Document{} = document) do - project = Engine.get_project() + project = Forge.get_project() with :ok <- Build.compile_document(project, document), {:ok, formatted} <- do_format(project, document) do @@ -163,8 +163,8 @@ defmodule Engine.CodeMod.Format do fetch_formatter = fn _ -> Mix.Tasks.Format.formatter_for_file(file_path) end {formatter_function, opts} = - if Engine.project_node?() do - case Engine.Mix.in_project(project, fetch_formatter) do + if Forge.project_node?() do + case Forge.Mix.in_project(project, fetch_formatter) do {:ok, result} -> result diff --git a/engine/lib/engine/dispatch.ex b/forge/lib/forge/dispatch.ex similarity index 89% rename from engine/lib/engine/dispatch.ex rename to forge/lib/forge/dispatch.ex index 6ba31581..c4a61e36 100644 --- a/engine/lib/engine/dispatch.ex +++ b/forge/lib/forge/dispatch.ex @@ -1,14 +1,14 @@ -defmodule Engine.Dispatch do +defmodule Forge.Dispatch do @moduledoc """ A global event dispatcher for lexical. Dispatch allows two recipients of its messages, processes and modules. A process must register itself via a call to `register_listener`, while a process must implement the - `Engine.Dispatch.Handler` behaviour and add the module to the @handlers module attribute. + `Forge.Dispatch.Handler` behaviour and add the module to the @handlers module attribute. """ - alias Engine.Dispatch.Handlers - alias Engine.Dispatch.PubSub + alias Forge.Dispatch.Handlers + alias Forge.Dispatch.PubSub import Forge.Api.Messages @handlers [PubSub, Handlers.Indexing] @@ -77,7 +77,7 @@ defmodule Engine.Dispatch do end defp progress_pid do - project = Engine.get_project() + project = Forge.get_project() manager_node_name = Engine.manager_node_name(project) :rpc.call(manager_node_name, Engine.Server.Project.Progress, :whereis, [project]) end diff --git a/engine/lib/engine/dispatch/handler.ex b/forge/lib/forge/dispatch/handler.ex similarity index 94% rename from engine/lib/engine/dispatch/handler.ex rename to forge/lib/forge/dispatch/handler.ex index b580ac75..1447003d 100644 --- a/engine/lib/engine/dispatch/handler.ex +++ b/forge/lib/forge/dispatch/handler.ex @@ -1,4 +1,4 @@ -defmodule Engine.Dispatch.Handler do +defmodule Forge.Dispatch.Handler do @moduledoc """ Defines a handler that selectively receives events emitted from a remote control node. @@ -8,7 +8,7 @@ defmodule Engine.Dispatch.Handler do defmodule MyHandler do alias Forge.Api.Messages - alias Engine.Dispatch.Handler + alias Forge.Dispatch.Handler import Messages @@ -23,7 +23,7 @@ defmodule Engine.Dispatch.Handler do Register the handler with dispatch: # The second argument here will be passed to the `init/1` callback - Engine.Dispatch.add_handler(MyHandler, init_arg) + Forge.Dispatch.add_handler(MyHandler, init_arg) """ @type event :: tuple() diff --git a/engine/lib/engine/dispatch/handlers/indexing.ex b/forge/lib/forge/dispatch/handlers/indexing.ex similarity index 87% rename from engine/lib/engine/dispatch/handlers/indexing.ex rename to forge/lib/forge/dispatch/handlers/indexing.ex index f9d2e34e..adf5e016 100644 --- a/engine/lib/engine/dispatch/handlers/indexing.ex +++ b/forge/lib/forge/dispatch/handlers/indexing.ex @@ -1,9 +1,9 @@ -defmodule Engine.Dispatch.Handlers.Indexing do +defmodule Forge.Dispatch.Handlers.Indexing do alias Forge.Document alias Forge.Api.Messages alias Engine.Commands - alias Engine.Dispatch - alias Engine.Search + alias Forge.Dispatch + alias Forge.Search require Logger import Messages diff --git a/engine/lib/engine/dispatch/pub_sub.ex b/forge/lib/forge/dispatch/pub_sub.ex similarity index 98% rename from engine/lib/engine/dispatch/pub_sub.ex rename to forge/lib/forge/dispatch/pub_sub.ex index e85b3583..747bcf28 100644 --- a/engine/lib/engine/dispatch/pub_sub.ex +++ b/forge/lib/forge/dispatch/pub_sub.ex @@ -1,4 +1,4 @@ -defmodule Engine.Dispatch.PubSub do +defmodule Forge.Dispatch.PubSub do @moduledoc """ A pubsub event handler for a gen_event controller. """ diff --git a/engine/lib/engine/formats.ex b/forge/lib/forge/formats.ex similarity index 98% rename from engine/lib/engine/formats.ex rename to forge/lib/forge/formats.ex index c7d7dcd7..9cfd6845 100644 --- a/engine/lib/engine/formats.ex +++ b/forge/lib/forge/formats.ex @@ -1,4 +1,4 @@ -defmodule Engine.Formats do +defmodule Forge.Formats do @moduledoc """ A collection of formatting functions """ diff --git a/engine/lib/engine/mix.ex b/forge/lib/forge/mix.ex similarity index 92% rename from engine/lib/engine/mix.ex rename to forge/lib/forge/mix.ex index b8757ed7..85e95f4b 100644 --- a/engine/lib/engine/mix.ex +++ b/forge/lib/forge/mix.ex @@ -1,9 +1,9 @@ -defmodule Engine.Mix do +defmodule Forge.Mix do alias Forge.Project def in_project(fun) do - if Engine.project_node?() do - in_project(Engine.get_project(), fun) + if Forge.project_node?() do + in_project(Forge.get_project(), fun) else {:error, :not_project_node} end diff --git a/engine/lib/engine/module/loader.ex b/forge/lib/forge/module/loader.ex similarity index 96% rename from engine/lib/engine/module/loader.ex rename to forge/lib/forge/module/loader.ex index b6fb1d59..92fa930b 100644 --- a/engine/lib/engine/module/loader.ex +++ b/forge/lib/forge/module/loader.ex @@ -1,4 +1,4 @@ -defmodule Engine.Module.Loader do +defmodule Forge.Module.Loader do @moduledoc """ Apparently, Code.ensure_loaded?/1 is pretty slow. I'm guessing because it has to do a round trip to the code server for each check. This in turn slows down indexing, so the thought diff --git a/engine/lib/engine/modules.ex b/forge/lib/forge/modules.ex similarity index 99% rename from engine/lib/engine/modules.ex rename to forge/lib/forge/modules.ex index f278e026..def6a9f6 100644 --- a/engine/lib/engine/modules.ex +++ b/forge/lib/forge/modules.ex @@ -1,10 +1,10 @@ -defmodule Engine.Modules do +defmodule Forge.Modules do @moduledoc """ Utilities for dealing with modules on the remote control node """ alias Future.Code.Typespec - alias Engine.Module.Loader + alias Forge.Module.Loader @typedoc "Module documentation record as defined by EEP-48" @type docs_v1 :: tuple() diff --git a/engine/lib/engine/search/fuzzy.ex b/forge/lib/forge/search/fuzzy.ex similarity index 97% rename from engine/lib/engine/search/fuzzy.ex rename to forge/lib/forge/search/fuzzy.ex index 16b733df..46e16c19 100644 --- a/engine/lib/engine/search/fuzzy.ex +++ b/forge/lib/forge/search/fuzzy.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Fuzzy do +defmodule Forge.Search.Fuzzy do @moduledoc """ A backend for fuzzy matching @@ -13,7 +13,7 @@ defmodule Engine.Search.Fuzzy do alias Forge.Project - alias Engine.Search.Fuzzy.Scorer + alias Forge.Search.Fuzzy.Scorer alias Forge.Search.Indexer.Entry import Record @@ -289,7 +289,7 @@ defmodule Engine.Search.Fuzzy do end defp stringify(mapped(type: :module, subject: module_name)) do - Engine.Formats.module(module_name) + Forge.Formats.module(module_name) end defp stringify(mapped(subject: string)) when is_binary(string) do @@ -307,10 +307,10 @@ defmodule Engine.Search.Fuzzy do defp stringify(atom) when is_atom(atom) do cond do function_exported?(atom, :__info__, 1) -> - Engine.Formats.module(atom) + Forge.Formats.module(atom) function_exported?(atom, :module_info, 0) -> - Engine.Formats.module(atom) + Forge.Formats.module(atom) true -> inspect(atom) @@ -340,7 +340,7 @@ defmodule Engine.Search.Fuzzy do deps_roots() else {:ok, deps_roots} = - Engine.Mix.in_project(fn _ -> + Forge.Mix.in_project(fn _ -> deps_roots() end) @@ -359,7 +359,7 @@ defmodule Engine.Search.Fuzzy do end defp deps_roots do - deps_roots(Engine.get_project()) + deps_roots(Forge.get_project()) end defp deps_roots(%Project{mix_project?: true} = project) do diff --git a/forge/lib/forge/search/fuzzy/scorer.ex b/forge/lib/forge/search/fuzzy/scorer.ex index f5e31486..e23e95a8 100644 --- a/forge/lib/forge/search/fuzzy/scorer.ex +++ b/forge/lib/forge/search/fuzzy/scorer.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Fuzzy.Scorer do +defmodule Forge.Search.Fuzzy.Scorer do @moduledoc """ Scores a match based on heuristics. diff --git a/engine/lib/engine/search/indexer.ex b/forge/lib/forge/search/indexer.ex similarity index 97% rename from engine/lib/engine/search/indexer.ex rename to forge/lib/forge/search/indexer.ex index d86859fa..a76fde1f 100644 --- a/engine/lib/engine/search/indexer.ex +++ b/forge/lib/forge/search/indexer.ex @@ -196,14 +196,14 @@ defmodule Forge.Search.Indexer do end defp deps_dir do - case Engine.Mix.in_project(&Mix.Project.deps_path/0) do + case Forge.Mix.in_project(&Mix.Project.deps_path/0) do {:ok, path} -> path _ -> Mix.Project.deps_path() end end defp build_dir do - case Engine.Mix.in_project(&Mix.Project.build_path/0) do + case Forge.Mix.in_project(&Mix.Project.build_path/0) do {:ok, path} -> path _ -> Mix.Project.build_path() end diff --git a/forge/lib/forge/search/indexer/extractors/ex_unit.ex b/forge/lib/forge/search/indexer/extractors/ex_unit.ex index a27fcd86..855ac6d7 100644 --- a/forge/lib/forge/search/indexer/extractors/ex_unit.ex +++ b/forge/lib/forge/search/indexer/extractors/ex_unit.ex @@ -3,7 +3,7 @@ defmodule Forge.Search.Indexer.Extractors.ExUnit do alias Forge.Ast.Analysis alias Forge.Document.Position alias Forge.Document.Range - alias Engine.Formats + alias Forge.Formats alias Forge.Analyzer alias Forge.Search.Indexer.Entry alias Forge.Search.Indexer.Metadata diff --git a/forge/lib/forge/search/indexer/extractors/function_definition.ex b/forge/lib/forge/search/indexer/extractors/function_definition.ex index c7a37e02..02326c89 100644 --- a/forge/lib/forge/search/indexer/extractors/function_definition.ex +++ b/forge/lib/forge/search/indexer/extractors/function_definition.ex @@ -4,7 +4,7 @@ defmodule Forge.Search.Indexer.Extractors.FunctionDefinition do alias Forge.Analyzer alias Forge.Search.Indexer.Entry alias Forge.Search.Indexer.Source.Reducer - alias Engine.Search.Subject + alias Forge.Search.Subject @function_definitions [:def, :defp] diff --git a/forge/lib/forge/search/indexer/extractors/function_reference.ex b/forge/lib/forge/search/indexer/extractors/function_reference.ex index 53c9b364..57eb917a 100644 --- a/forge/lib/forge/search/indexer/extractors/function_reference.ex +++ b/forge/lib/forge/search/indexer/extractors/function_reference.ex @@ -7,7 +7,7 @@ defmodule Forge.Search.Indexer.Extractors.FunctionReference do alias Forge.Search.Indexer.Extractors.FunctionDefinition alias Forge.Search.Indexer.Metadata alias Forge.Search.Indexer.Source.Reducer - alias Engine.Search.Subject + alias Forge.Search.Subject require Logger @@ -110,7 +110,7 @@ defmodule Forge.Search.Indexer.Extractors.FunctionReference do Entry.reference( analysis.document.path, Reducer.current_block(reducer), - Engine.Formats.mfa(module, function_name, arity), + Forge.Formats.mfa(module, function_name, arity), {:function, :usage}, Ast.Range.get(ast, analysis.document), Application.get_application(module) diff --git a/forge/lib/forge/search/indexer/extractors/module.ex b/forge/lib/forge/search/indexer/extractors/module.ex index a24f8cfb..a7c40c7d 100644 --- a/forge/lib/forge/search/indexer/extractors/module.ex +++ b/forge/lib/forge/search/indexer/extractors/module.ex @@ -12,7 +12,7 @@ defmodule Forge.Search.Indexer.Extractors.Module do alias Forge.Search.Indexer.Metadata alias Forge.Search.Indexer.Source.Block alias Forge.Search.Indexer.Source.Reducer - alias Engine.Search.Subject + alias Forge.Search.Subject require Logger diff --git a/forge/lib/forge/search/indexer/extractors/module_attribute.ex b/forge/lib/forge/search/indexer/extractors/module_attribute.ex index fd90c7cb..c63315ca 100644 --- a/forge/lib/forge/search/indexer/extractors/module_attribute.ex +++ b/forge/lib/forge/search/indexer/extractors/module_attribute.ex @@ -8,7 +8,7 @@ defmodule Forge.Search.Indexer.Extractors.ModuleAttribute do alias Forge.Analyzer alias Forge.Search.Indexer.Entry alias Forge.Search.Indexer.Source.Reducer - alias Engine.Search.Subject + alias Forge.Search.Subject require Logger diff --git a/forge/lib/forge/search/indexer/extractors/struct_reference.ex b/forge/lib/forge/search/indexer/extractors/struct_reference.ex index fe66d480..38c401f3 100644 --- a/forge/lib/forge/search/indexer/extractors/struct_reference.ex +++ b/forge/lib/forge/search/indexer/extractors/struct_reference.ex @@ -3,7 +3,7 @@ defmodule Forge.Search.Indexer.Extractors.StructReference do alias Forge.Analyzer alias Forge.Search.Indexer.Entry alias Forge.Search.Indexer.Source.Reducer - alias Engine.Search.Subject + alias Forge.Search.Subject require Logger diff --git a/engine/lib/engine/search/store.ex b/forge/lib/forge/search/store.ex similarity index 97% rename from engine/lib/engine/search/store.ex rename to forge/lib/forge/search/store.ex index 0d3435b3..87723269 100644 --- a/engine/lib/engine/search/store.ex +++ b/forge/lib/forge/search/store.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Store do +defmodule Forge.Search.Store do @moduledoc """ A persistent store for search entries """ @@ -7,8 +7,8 @@ defmodule Engine.Search.Store do alias Forge.Api alias Forge.Search.Indexer.Entry - alias Engine.Search.Store - alias Engine.Search.Store.State + alias Forge.Search.Store + alias Forge.Search.Store.State @type index_state :: :empty | :stale @type existing_entries :: [Entry.t()] @@ -108,7 +108,7 @@ defmodule Engine.Search.Store do end defp normalize_init_args([create_index, refresh_index]) do - normalize_init_args([Engine.get_project(), create_index, refresh_index]) + normalize_init_args([Forge.get_project(), create_index, refresh_index]) end defp normalize_init_args([%Project{} = project, create_index, refresh_index]) do diff --git a/engine/lib/engine/search/store/backend.ex b/forge/lib/forge/search/store/backend.ex similarity index 98% rename from engine/lib/engine/search/store/backend.ex rename to forge/lib/forge/search/store/backend.ex index 9313c317..d7445372 100644 --- a/engine/lib/engine/search/store/backend.ex +++ b/forge/lib/forge/search/store/backend.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Store.Backend do +defmodule Forge.Search.Store.Backend do @moduledoc """ A behaviour for search store backends """ diff --git a/engine/lib/engine/search/store/backends/ets.ex b/forge/lib/forge/search/store/backends/ets.ex similarity index 95% rename from engine/lib/engine/search/store/backends/ets.ex rename to forge/lib/forge/search/store/backends/ets.ex index 9cf97670..72d4bf51 100644 --- a/engine/lib/engine/search/store/backends/ets.ex +++ b/forge/lib/forge/search/store/backends/ets.ex @@ -1,9 +1,9 @@ -defmodule Engine.Search.Store.Backends.Ets do +defmodule Forge.Search.Store.Backends.Ets do alias Forge.Project alias Forge.Search.Indexer.Entry - alias Engine.Search.Store.Backend - alias Engine.Search.Store.Backends.Ets.State + alias Forge.Search.Store.Backend + alias Forge.Search.Store.Backends.Ets.State use GenServer @@ -94,7 +94,7 @@ defmodule Engine.Search.Store.Backends.Ets do end def start_link do - start_link(Engine.get_project()) + start_link(Forge.get_project()) end def child_spec([%Project{}] = init_args) do @@ -102,7 +102,7 @@ defmodule Engine.Search.Store.Backends.Ets do end def child_spec(_) do - child_spec([Engine.get_project()]) + child_spec([Forge.get_project()]) end @impl GenServer @@ -179,7 +179,7 @@ defmodule Engine.Search.Store.Backends.Ets do end defp genserver_name do - genserver_name(Engine.get_project()) + genserver_name(Forge.get_project()) end defp genserver_name(%Project{} = project) do diff --git a/engine/lib/engine/search/store/backends/ets/schema.ex b/forge/lib/forge/search/store/backends/ets/schema.ex similarity index 98% rename from engine/lib/engine/search/store/backends/ets/schema.ex rename to forge/lib/forge/search/store/backends/ets/schema.ex index 3618c979..08ebd3b7 100644 --- a/engine/lib/engine/search/store/backends/ets/schema.ex +++ b/forge/lib/forge/search/store/backends/ets/schema.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Store.Backends.Ets.Schema do +defmodule Forge.Search.Store.Backends.Ets.Schema do @moduledoc """ A use-able module that allows ETS schemas to be created and migrated. @@ -45,7 +45,7 @@ defmodule Engine.Search.Store.Backends.Ets.Schema do alias Forge.Project alias Forge.Search.Indexer.Entry - alias Engine.Search.Store.Backends.Ets.Wal + alias Forge.Search.Store.Backends.Ets.Wal import Wal, only: :macros diff --git a/engine/lib/engine/search/store/backends/ets/schemas/legacy_v0.ex b/forge/lib/forge/search/store/backends/ets/schemas/legacy_v0.ex similarity index 74% rename from engine/lib/engine/search/store/backends/ets/schemas/legacy_v0.ex rename to forge/lib/forge/search/store/backends/ets/schemas/legacy_v0.ex index 65c1155d..5127fe32 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/legacy_v0.ex +++ b/forge/lib/forge/search/store/backends/ets/schemas/legacy_v0.ex @@ -1,11 +1,11 @@ -defmodule Engine.Search.Store.Backends.Ets.Schemas.LegacyV0 do +defmodule Forge.Search.Store.Backends.Ets.Schemas.LegacyV0 do @moduledoc """ A legacy version of the schema. We pushed the initial indexer to main before we added schemas and versioning. This represents that schema type, hence the non-versioned name. """ - alias Engine.Search.Store.Backends.Ets.Schema + alias Forge.Search.Store.Backends.Ets.Schema use Schema, version: 0 diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v1.ex b/forge/lib/forge/search/store/backends/ets/schemas/v1.ex similarity index 94% rename from engine/lib/engine/search/store/backends/ets/schemas/v1.ex rename to forge/lib/forge/search/store/backends/ets/schemas/v1.ex index 131051fc..f7703360 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/v1.ex +++ b/forge/lib/forge/search/store/backends/ets/schemas/v1.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Store.Backends.Ets.Schemas.V1 do +defmodule Forge.Search.Store.Backends.Ets.Schemas.V1 do @moduledoc """ This schema uses a bit of data duplication in order to achieve good performance. @@ -10,7 +10,7 @@ defmodule Engine.Search.Store.Backends.Ets.Schemas.V1 do """ alias Forge.Search.Indexer.Entry - alias Engine.Search.Store.Backends.Ets.Schema + alias Forge.Search.Store.Backends.Ets.Schema use Schema, version: 1 diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v2.ex b/forge/lib/forge/search/store/backends/ets/schemas/v2.ex similarity index 93% rename from engine/lib/engine/search/store/backends/ets/schemas/v2.ex rename to forge/lib/forge/search/store/backends/ets/schemas/v2.ex index f67b7016..c044b6d2 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/v2.ex +++ b/forge/lib/forge/search/store/backends/ets/schemas/v2.ex @@ -1,6 +1,6 @@ -defmodule Engine.Search.Store.Backends.Ets.Schemas.V2 do +defmodule Forge.Search.Store.Backends.Ets.Schemas.V2 do alias Forge.Search.Indexer.Entry - alias Engine.Search.Store.Backends.Ets.Schema + alias Forge.Search.Store.Backends.Ets.Schema require Entry use Schema, version: 2 diff --git a/engine/lib/engine/search/store/backends/ets/schemas/v3.ex b/forge/lib/forge/search/store/backends/ets/schemas/v3.ex similarity index 94% rename from engine/lib/engine/search/store/backends/ets/schemas/v3.ex rename to forge/lib/forge/search/store/backends/ets/schemas/v3.ex index 64507e5a..bbd2aa35 100644 --- a/engine/lib/engine/search/store/backends/ets/schemas/v3.ex +++ b/forge/lib/forge/search/store/backends/ets/schemas/v3.ex @@ -1,6 +1,6 @@ -defmodule Engine.Search.Store.Backends.Ets.Schemas.V3 do +defmodule Forge.Search.Store.Backends.Ets.Schemas.V3 do alias Forge.Search.Indexer.Entry - alias Engine.Search.Store.Backends.Ets.Schema + alias Forge.Search.Store.Backends.Ets.Schema require Entry use Schema, version: 3 diff --git a/engine/lib/engine/search/store/backends/ets/state.ex b/forge/lib/forge/search/store/backends/ets/state.ex similarity index 97% rename from engine/lib/engine/search/store/backends/ets/state.ex rename to forge/lib/forge/search/store/backends/ets/state.ex index b190a86b..56816a37 100644 --- a/engine/lib/engine/search/store/backends/ets/state.ex +++ b/forge/lib/forge/search/store/backends/ets/state.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Store.Backends.Ets.State do +defmodule Forge.Search.Store.Backends.Ets.State do @moduledoc """ An ETS based search backend @@ -7,9 +7,9 @@ defmodule Engine.Search.Store.Backends.Ets.State do """ alias Forge.Project alias Forge.Search.Indexer.Entry - alias Engine.Search.Store.Backends.Ets.Schema - alias Engine.Search.Store.Backends.Ets.Schemas - alias Engine.Search.Store.Backends.Ets.Wal + alias Forge.Search.Store.Backends.Ets.Schema + alias Forge.Search.Store.Backends.Ets.Schemas + alias Forge.Search.Store.Backends.Ets.Wal @schema_order [ Schemas.LegacyV0, diff --git a/engine/lib/engine/search/store/backends/ets/wal.ex b/forge/lib/forge/search/store/backends/ets/wal.ex similarity index 99% rename from engine/lib/engine/search/store/backends/ets/wal.ex rename to forge/lib/forge/search/store/backends/ets/wal.ex index 401e6f5a..76049662 100644 --- a/engine/lib/engine/search/store/backends/ets/wal.ex +++ b/forge/lib/forge/search/store/backends/ets/wal.ex @@ -1,4 +1,4 @@ -defmodule Engine.Search.Store.Backends.Ets.Wal do +defmodule Forge.Search.Store.Backends.Ets.Wal do @moduledoc """ A (hopefully) simple write-ahead log """ diff --git a/engine/lib/engine/search/store/state.ex b/forge/lib/forge/search/store/state.ex similarity index 98% rename from engine/lib/engine/search/store/state.ex rename to forge/lib/forge/search/store/state.ex index 4e89142e..3539a2e4 100644 --- a/engine/lib/engine/search/store/state.ex +++ b/forge/lib/forge/search/store/state.ex @@ -1,8 +1,8 @@ -defmodule Engine.Search.Store.State do +defmodule Forge.Search.Store.State do alias Forge.Project alias Forge.Api.Messages - alias Engine.Dispatch - alias Engine.Search.Fuzzy + alias Forge.Dispatch + alias Forge.Search.Fuzzy alias Forge.Search.Indexer.Entry require Logger diff --git a/engine/lib/engine/search/subject.ex b/forge/lib/forge/search/subject.ex similarity index 83% rename from engine/lib/engine/search/subject.ex rename to forge/lib/forge/search/subject.ex index 5308f3a6..c278fc1e 100644 --- a/engine/lib/engine/search/subject.ex +++ b/forge/lib/forge/search/subject.ex @@ -1,8 +1,8 @@ -defmodule Engine.Search.Subject do +defmodule Forge.Search.Subject do @moduledoc """ Functions for converting to a search entry's subject field """ - alias Engine.Formats + alias Forge.Formats def module(module) do module diff --git a/engine/lib/engine/text.ex b/forge/lib/forge/text.ex similarity index 90% rename from engine/lib/engine/text.ex rename to forge/lib/forge/text.ex index 395c9bbd..ce115dec 100644 --- a/engine/lib/engine/text.ex +++ b/forge/lib/forge/text.ex @@ -1,4 +1,4 @@ -defmodule Engine.Text do +defmodule Forge.Text do def count_leading_spaces(str), do: count_leading_spaces(str, 0) def count_leading_spaces(<>, count) when c in [?\s, ?\t], diff --git a/forge/mix.exs b/forge/mix.exs index 6d18ed7b..dcc3524d 100644 --- a/forge/mix.exs +++ b/forge/mix.exs @@ -23,7 +23,9 @@ defmodule Forge.MixProject do defp deps do [ {:sourceror, "~> 1.0"}, - {:snowflake, "~> 1.0"} + {:snowflake, "~> 1.0"}, + {:elixir_sense, github: "elixir-lsp/elixir_sense"}, + {:namespace, path: "../namespace/"} # {:dep_from_hexpm, "~> 0.3.0"}, # {:dep_from_git, git: "https://github.com/elixir-lang/my_dep.git", tag: "0.1.0"} diff --git a/forge/mix.lock b/forge/mix.lock index bf7c5158..90f0d35c 100644 --- a/forge/mix.lock +++ b/forge/mix.lock @@ -1,4 +1,5 @@ %{ + "elixir_sense": {:git, "https://github.com/elixir-lsp/elixir_sense.git", "706c498be371882366151b588e5cd13c9c08404c", []}, "snowflake": {:hex, :snowflake, "1.0.4", "8433b4e04fbed19272c55e1b7de0f7a1ee1230b3ae31a813b616fd6ef279e87a", [:mix], [], "hexpm", "badb07ebb089a5cff737738297513db3962760b10fe2b158ae3bebf0b4d5be13"}, "sourceror": {:hex, :sourceror, "1.7.1", "599d78f4cc2be7d55c9c4fd0a8d772fd0478e3a50e726697c20d13d02aa056d4", [:mix], [], "hexpm", "cd6f268fe29fa00afbc535e215158680a0662b357dc784646d7dff28ac65a0fc"}, }