zigler

defmodule Zig.Parser do
  @moduledoc """
  main parsing module:  Handles general parsing of nif, resource directives
  and code elements succeeding those.
  """

  @enforce_keys [:module]

  defstruct [:local, file: "", zig_block_line: 0, global: []] ++ @enforce_keys

  require Logger

  import NimbleParsec

  alias Zig.Parser.{Nif, Resource, ResourceCleanup}

  @type t :: %__MODULE__{
    local: Nif.t | ResourceCleanup.t | {:doc, iodata},
    file: Path.t,
    zig_block_line: non_neg_integer,
    global: [Nif.t],
    module: module
  }

  @type line_info :: {non_neg_integer, non_neg_integer}
  @type parsec_retval :: {[String.t], t}

  @alphanumeric [?a..?z, ?A..?Z, ?0..?9, ?_]
  @number [?0..?9]

  #############################################################################
  ## GENERIC NIMBLE_PARSEC PARSERS

  whitespace = ascii_string([?\s, ?\n], min: 1)
  blankspace = ignore(ascii_string([?\s], min: 1))
  # note that tabs are forbidden by zig.

  identifier =
    ascii_char([?a..?z, ?A..?Z, ?_])
    |> optional(ascii_string(@alphanumeric, min: 1))
    |> reduce({IO, :iodata_to_binary, []})

  namespaced_identifier =
    identifier
    |> repeat(concat(string("."), identifier))
    |> reduce({IO, :iodata_to_binary, []})

  number = ascii_string(@number, min: 1)

  error_decorator = string("!")
  pointer_decorator =
    optional(string("?") |> ignore(optional(whitespace)))
    |> string("*")

  array_decorator = string("[")
    |> ignore(optional(whitespace))
    |> optional(string("*c") |> optional(whitespace))
    |> string("]")

  decorator = choice([
    pointer_decorator,
    array_decorator
  ])

  type =
    optional(error_decorator |> ignore(optional(whitespace)))
    |> repeat(decorator |> ignore(optional(whitespace)))
    |> concat(namespaced_identifier)
    |> reduce({IO, :iodata_to_binary, []})

  #############################################################################
  ## INITIALIZATION
  ##
  ## used to initialize nimble_parsec with a struct instead of a generic map.
  ## should be prepended to most things which are turned into parsecs.  You
  ## can also pass information into a parsec function to preseed the context.

  initialize = post_traverse(empty(), :initializer)

  @spec initializer(String.t, [String.t], t, line_info, non_neg_integer)
    :: parsec_retval

  defp initializer(_, _, context, _, _), do: {[], struct(__MODULE__, context)}

  # test harness

  if Mix.env == :test do
    defparsec :parser_initializer, initialize
  end

  #############################################################################
  ## DOCSTRING PARSING
  ##
  ## certain zigler arguments are encoded in zig's /// docstrings.
  ## this includes definitions for nifs and destructors for resources.

  @nif_options Enum.map(~w(yielding threaded dirty_io dirty_cpu), &string/1)

  docstring_line =
    optional(blankspace)
    |> ignore(string("///"))
    |> lookahead_not(string("/"))
    |> optional(blankspace)
    |> lookahead_not(choice([string("nif:"), string("resource:")]))
    |> optional(utf8_string([not: ?\n], min: 1))
    |> ignore(string("\n"))
    |> post_traverse(:register_docstring_line)

  nif_options = repeat(blankspace |> choice(@nif_options))

  # nif declarations take the form:
  # /// nif: <nif_name>/<arity> [nif_options]
  # where nif_options can be "yielding", "threaded", "dirty_io", or "dirty_cpu"
  nif_declaration =
    optional(blankspace)
    |> ignore(string("///"))
    |> optional(blankspace)
    |> ignore(string("nif:"))
    |> concat(blankspace)
    |> concat(identifier)
    |> ignore(string("/"))
    |> concat(number)
    |> optional(nif_options)
    |> optional(blankspace)
    |> ignore(string("\n"))
    |> post_traverse(:register_nif_declaration)

  # resource declarations take the form:
  # /// resource: <resource_type> <definition | cleanup>
  resource_modifier = Enum.map(~w(definition cleanup), &string/1)

  resource_declaration =
    optional(blankspace)
    |> ignore(string("///"))
    |> optional(blankspace)
    |> ignore(string("resource:"))
    |> concat(blankspace)
    |> concat(identifier)
    |> optional(blankspace)
    |> choice(resource_modifier)
    |> ignore(string("\n"))
    |> post_traverse(:register_resource_declaration)

  docstring =
    choice([
      times(docstring_line, min: 1)
      |> optional(choice([nif_declaration, resource_declaration])),
      nif_declaration,
      resource_declaration
    ])

  # test harness

  if Mix.env == :test do
    defparsec :parse_docstring_line,       concat(initialize, docstring_line)
    defparsec :parse_nif_declaration,      concat(initialize, nif_declaration)
    defparsec :parse_resource_declaration, concat(initialize, resource_declaration)
    defparsec :parse_docstring,            concat(initialize, docstring)
  end

  # warn on bad declarations.
  bad_declaration = ignore(
    optional(blankspace)
    |> string("//")
    |> optional(blankspace)
    |> choice([string("nif"), string("resource")])
    |> string(":")
    |> optional(ascii_string([not: ?\n], min: 1))
    |> string("\n"))
  |> post_traverse(:warn_on_bad_declaration)

  # registrations

  @spec register_docstring_line(String.t, [String.t], t, line_info, non_neg_integer)
    :: parsec_retval

  # empty docstring line.
  defp register_docstring_line(_rest, [], context = %{local: {:doc, doc}}, _, _) do
    {[], %{context | local: {:doc, [doc, ?\n]}}}
  end
  defp register_docstring_line(_rest, [], context = %{local: nil}, _, _) do
    {[], %{context | local: nil}}
  end
  defp register_docstring_line(_rest, [content], context = %{local: {:doc, doc}}, _, _) do
    {[], %{context | local: {:doc, [doc, ?\n | String.trim(content)]}}}
  end
  defp register_docstring_line(_rest, [content], context = %{local: nil}, _, _) do
    {[], %{context | local: {:doc, String.trim(content)}}}
  end
  defp register_docstring_line(_rest, [_content], context, {line, _}, _) do
    raise SyntaxError,
      file: context.file,
      line: line + context.zig_block_line,
      description: "docstring found in an inappropriate context"
  end

  # register_nif_declaration/5: trampolines into register_nif_declaration/3
  @spec register_nif_declaration(String.t, [String.t], t, line_info, non_neg_integer)
    :: parsec_retval
  defp register_nif_declaration(_rest, content, context, _, _) do
    register_nif_declaration(content, context, [])
  end
  # register_nif_declaration/3
  @spec register_nif_declaration([String.t], t, keyword)
    :: parsec_retval
  defp register_nif_declaration(content, context = %{local: {:doc, doc}}, opts) do
    register_nif_declaration(content, %{context | local: nil}, opts ++ [doc: doc])
  end
  defp register_nif_declaration(["yielding" | rest], context, opts) do
    register_nif_declaration(rest, context, opts ++ [concurrency: :yielding])
  end
  defp register_nif_declaration(["threaded" | rest], context, opts) do
    register_nif_declaration(rest, context, opts ++ [concurrency: :threaded])
  end
  defp register_nif_declaration(["dirty_io" | rest], context, opts) do
    register_nif_declaration(rest, context, opts ++ [concurrency: :dirty_io])
  end
  defp register_nif_declaration(["dirty_cpu" | rest], context, opts) do
    register_nif_declaration(rest, context, opts ++ [concurrency: :dirty_cpu])
  end
  defp register_nif_declaration([arity, name], context, opts) do
    local = struct(Nif,
      module: context.module,
      name:  String.to_atom(name),
      arity: String.to_integer(arity),
      doc:   opts[:doc],
      opts:  Keyword.take(opts, [:concurrency]))
    {[], %{context | local: local}}
  end

  defp register_resource_declaration(_rest, ["definition", name], context, _, _) do
    {[], %{context | local: resource_struct(name, context)}}
  end
  defp register_resource_declaration(_rest, ["cleanup", name], context, _, _) do
    {[], %{context | local: resource_cleanup_struct(name, context)}}
  end

  defp resource_struct(name, context = %{local: {:doc, doc}}) do
    struct(resource_struct(name, %{context | local: nil}), doc: doc)
  end
  defp resource_struct(name, _context) do
    struct(Resource, name: String.to_atom(name))
  end

  defp resource_cleanup_struct(name, context = %{local: {:doc, doc}}) do
    struct(resource_cleanup_struct(name, %{context | local: nil}), doc: doc)
  end
  defp resource_cleanup_struct(name, _context) do
    struct(ResourceCleanup, for: String.to_atom(name))
  end

  defp warn_on_bad_declaration(_rest, _content, context, {line, _}, _) do
    Logger.warn("nif or resource declaration missing third slash, (#{context.file} line #{line})")
    {[], context}
  end

  #############################################################################
  ## FUNCTION HEADER PARSING

  argument =
    ignore(
      identifier
      |> optional(whitespace)
      |> string(":")
      |> optional(whitespace))
    |> concat(type)

  argument_list =
    ignore(optional(whitespace))
    |> optional(argument)
    |> repeat(
      ignore(
        optional(whitespace)
        |> string(",")
        |> optional(whitespace))
      |> concat(argument))

  function_header =
    ignore(
      optional(blankspace)
      |> string("fn")
      |> concat(whitespace))
    |> concat(identifier)
    |> post_traverse(:validate_nif_declaration)
    |> ignore(optional(whitespace) |> string("("))
    |> concat(argument_list)
    |> ignore(string(")") |> optional(whitespace))
    |> post_traverse(:validate_arity)
    |> post_traverse(:validate_args)
    |> concat(type)
    |> post_traverse(:validate_retval)
    |> ignore(
      repeat(ascii_char(not: ?\n))
      |> string("\n"))
    |> post_traverse(:register_function_header)

  resource_definition =
    ignore(
      optional(blankspace)
      |> string("const")
      |> concat(whitespace))
    |> concat(identifier)
    |> post_traverse(:validate_resource)
    |> optional(blankspace)
    |> ignore(
      string("=")
      |> repeat(ascii_char(not: ?\n))
      |> string("\n"))
    |> post_traverse(:register_resource_definition)
  # test harness

  if Mix.env == :test do
    defparsec :parse_argument, concat(initialize, argument)
    defparsec :parse_argument_list, concat(initialize, argument_list)
    defparsec :parse_function_header, concat(initialize, function_header)
    defparsec :parse_resource_definition, concat(initialize, resource_definition)
  end

  # validations

  @spec validate_nif_declaration(String.t, [String.t], t, line_info, non_neg_integer)
    :: parsec_retval | no_return
  defp validate_nif_declaration(_rest, [nif_name], context = %{local: %Nif{name: name}}, {line, _}, _) do
    unless nif_name == Atom.to_string(name) do
      raise SyntaxError,
        file: context.file,
        line: line + context.zig_block_line - 1,
        description: "nif declaration name #{name} doesn't match function name #{nif_name}"
    end
    {[], context}
  end
  defp validate_nif_declaration(_, content, context, _, _), do: {content, context}

  # validate_arity/5: trampolines into module.validate_arity/3
  @spec validate_arity(String.t, [String.t], t, line_info, non_neg_integer)
    :: parsec_retval | no_return
  defp validate_arity(_rest, args, context = %{local: %module{}}, {line, _}, _) do
    args
    |> Enum.reverse
    |> module.validate_arity(context, line)
    {args, context}
  end
  defp validate_arity(_rest, content, context, _, _), do: {content, context}

  # validate_args/5 : trampolines to module.validate_args/3
  # ignore argument validation if we're not in a segment specified by a nif.
  @spec validate_args(String.t, [String.t], t, line_info, non_neg_integer)
    :: parsec_retval | no_return
  defp validate_args(_rest, content, context = %{local: %module{}}, {line, _}, _) do
    module.validate_args(content, context, line)
    {content, context}
  end
  defp validate_args(_, content, context, _, _), do: {content, context}

  # validate_retval/5 : trampolines to module.validate_args/3
  @spec validate_retval(String.t, [String.t], t, line_info, non_neg_integer)
    :: parsec_retval | no_return
  defp validate_retval(_rest, content, context = %{local: %module{}}, {line, _}, _) do
    module.validate_retval(content, context, line)
    {content, context}
  end
  defp validate_retval(_, content, context, _, _), do: {content, context}

  @spec validate_resource(String.t, [String.t], t, line_info, non_neg_integer)
    :: parsec_retval | no_return
  defp validate_resource(_, [name], context = %{local: resource = %Resource{}}, {line, _}, _) do
    unless Atom.to_string(resource.name) == name do
      raise SyntaxError,
        file: context.file,
        line: line + context.zig_block_line - 1,
        description: "resource declaration #{resource.name} doesn't match succeeding const identifier #{name}"
    end
    {[], context}
  end
  defp validate_resource(_, _, context, _, _), do: {[], context}

  # registrations

  @spec register_function_header(String.t, [String.t], t, line_info, non_neg_integer)
    :: parsec_retval

  defp register_function_header(_, content, context = %{local: %module{}}, _, _) do
    {[], %{module.register_function_header(content, context) | local: nil}}
  end
  defp register_function_header(_, _, context, _, _), do: {[], %{context | local: nil}}

  defp register_resource_definition(_, _, context = %{local: %Resource{}}, _, _) do
    {[], %{Resource.register_resource_definition(context) | local: nil}}
  end
  defp register_resource_definition(_, _, context, _, _), do: {[], context}

  #############################################################################
  ## FULL PARSER

  ignored_line =
    optional(utf8_string([not: ?\n], min: 1))
    |> string("\n")
    |> post_traverse(:clear)

  zig_block =
    initialize
    |> repeat(choice([
      docstring,
      function_header,
      resource_definition,
      bad_declaration,
      ignored_line,
    ]))

  defparsec :parse_zig_block, zig_block

  @spec clear(String.t, [String.t], t, line_info, non_neg_integer) :: parsec_retval

  defp clear(_rest, _content, context = %{local: nil}, _, _) do
    {[], context}
  end
  defp clear(_rest, _content, context = %{local: {:doc, _}}, _, _) do
    {[], context}
  end
  defp clear(_rest, _content, context = %{local: %type{}}, {line, _}, _) do
    msg = case type do
      Nif ->
        "incomplete nif declaration"
      Resource ->
        "incomplete resource declaration"
      ResourceCleanup ->
        "incomplete resource cleanup declaration"
    end
    raise SyntaxError,
      file: context.file,
      line: line + context.zig_block_line - 1,
      description: msg
  end

  #############################################################################
  ## API

  @spec parse(String.t, Zig.Module.t, Path.t, non_neg_integer) :: Zig.Module.t
  def parse(code, old_module, file, line) do
    context = old_module
    |> Map.from_struct
    |> Map.put(:zig_block_line, line)

    case parse_zig_block(code, context: context) do
      {:ok, [], "", parser, _, _} ->
        append(old_module, parser, code, file, line)
      {:error, msg, _rest, _context, {ctx_line, _}, _} ->
        raise SyntaxError,
          file: old_module.file,
          line: ctx_line + context.zig_block_line,
          description: msg
      err ->
        raise SyntaxError,
          file: old_module.file,
          line: line + context.zig_block_line,
          description: "unknown parsing error #{inspect err}"
    end
  end

  #############################################################################
  ## helpers

  defp append(old_module, %{global: global}, code, file, line) do
    spacer = if old_module.code == [], do: [], else: "\n"
    anchor = "// ref: #{file} line: #{line}\n"

    new_nifs = Enum.filter(global, &match?(%Nif{}, &1))
    new_resources = Enum.filter(global, &match?(%Resource{}, &1))
    %{old_module |
      nifs: old_module.nifs ++ new_nifs,
      resources: old_module.resources ++ new_resources,
      code: [old_module.code, spacer, anchor, String.trim(code), "\n"]}
  end
end