@spec bin_segment(
  meta_ast(),
  keyword()
) :: meta_ast()

Create a bitstring segment node (Cure v0.20.0+).

Segments appear as children of {:literal, [subtype: :bytes], [...]} nodes and mirror Elixir's <<value::type-size(n)-unit(u)-sign-endian>> grammar. The value is a conforming MetaAST node; the accepted meta keys are :type, :signedness, :endianness, :size (AST node) and :unit (integer).

Examples

iex> v = {:variable, [], "x"}
iex> Metastatic.AST.bin_segment(v, type: :utf8)
{:bin_segment, [type: :utf8], [{:variable, [], "x"}]}

iex> v = {:variable, [], "rest"}
iex> Metastatic.AST.bin_segment(v, type: :binary)
{:bin_segment, [type: :binary], [{:variable, [], "rest"}]}

@spec binary_op(operator_category(), atom(), meta_ast(), meta_ast(), keyword()) ::
  meta_ast()

Create a binary operation node.

Examples

iex> left = {:variable, [], "x"}
iex> right = {:literal, [subtype: :integer], 5}
iex> Metastatic.AST.binary_op(:arithmetic, :+, left, right)
{:binary_op, [category: :arithmetic, operator: :+], [{:variable, [], "x"}, {:literal, [subtype: :integer], 5}]}

@spec block(
  [meta_ast()],
  keyword()
) :: meta_ast()

Create a block node.

Examples

iex> stmts = [{:variable, [], "x"}, {:literal, [subtype: :integer], 42}]
iex> Metastatic.AST.block(stmts)
{:block, [], [{:variable, [], "x"}, {:literal, [subtype: :integer], 42}]}

@spec children(meta_ast()) :: term()

Extract the children or value from a MetaAST node.

For leaf nodes (literal, variable), returns the value. For composite nodes, returns the list of children.

Examples

iex> Metastatic.AST.children({:literal, [subtype: :integer], 42})
42

iex> left = {:variable, [], "x"}
iex> right = {:literal, [subtype: :integer], 5}
iex> Metastatic.AST.children({:binary_op, [operator: :+], [left, right]})
[{:variable, [], "x"}, {:literal, [subtype: :integer], 5}]

@spec comment(String.t(), atom(), keyword()) :: meta_ast()

Create a trivia comment node (Cure v0.20.0+).

Comments are trivia: analyzers and code generators skip them, but formatters and documentation tooling need them back. kind is one of :line (plain # or //), :doc (Elixir @doc / Cure ##) or :block (C-style /* ... */).

Examples

iex> Metastatic.AST.comment("TODO: revisit")
{:comment, [comment_kind: :line], "TODO: revisit"}

iex> Metastatic.AST.comment("Public API entry point", :doc, line: 5)
{:comment, [comment_kind: :doc, line: 5], "Public API entry point"}

@spec comprehension(meta_ast(), [meta_ast()], keyword()) :: meta_ast()

Create a comprehension node.

Examples

iex> body = {:binary_op, [category: :arithmetic, operator: :*], [{:variable, [], "x"}, {:variable, [], "x"}]}
iex> gen = {:generator, [], [{:variable, [], "x"}, {:function_call, [name: "range"], [{:literal, [subtype: :integer], 10}]}]}
iex> Metastatic.AST.comprehension(body, [gen])
{:comprehension, [], [{:binary_op, [category: :arithmetic, operator: :*], [{:variable, [], "x"}, {:variable, [], "x"}]}, {:generator, [], [{:variable, [], "x"}, {:function_call, [name: "range"], [{:literal, [subtype: :integer], 10}]}]}]}

@spec conforms?(term()) :: boolean()

Validate that a term conforms to the M2 meta-model.

Checks that the structure is a valid 3-tuple MetaAST node with proper type, metadata, and children.

Examples

iex> Metastatic.AST.conforms?({:literal, [subtype: :integer], 42})
true

iex> Metastatic.AST.conforms?({:binary_op, [category: :arithmetic, operator: :+],
...>   [{:variable, [], "x"}, {:literal, [subtype: :integer], 5}]})
true

iex> Metastatic.AST.conforms?({:invalid_node, "data"})
false

iex> Metastatic.AST.conforms?("not a tuple")
false

@spec container(container_type(), String.t(), [meta_ast()], keyword()) :: meta_ast()

Create a container node.

Examples

iex> func_def1 = {:function_def, [name: "add", params: [{:param, [], "x"}, {:param, [], "y"}]], []}
iex> func_def2 = {:function_def, [name: "sub", params: [{:param, [], "x"}, {:param, [], "y"}]], []}
iex> Metastatic.AST.container(:module, "MyApp.Math", [func_def1, func_def2])
{:container, [container_type: :module, name: "MyApp.Math"], [{:function_def, [name: "add", params: [{:param, [], "x"}, {:param, [], "y"}]], []}, {:function_def, [name: "sub", params: [{:param, [], "x"}, {:param, [], "y"}]], []}]}

@spec container_name(meta_ast()) :: String.t() | nil

Extract the name from a container node.

Examples

iex> ast = {:container, [container_type: :module, name: "MyApp.Math"], []}
iex> Metastatic.AST.container_name(ast)
"MyApp.Math"

@spec decompose_call(meta_ast()) :: {String.t(), [meta_ast()]} | :error

Decomposes a function call into its name and argument list.

Returns {name, args} for :function_call nodes, or :error for any other node type.

For dotted calls like "Repo.get", returns the full dotted name as a string. Use String.split(name, ".") to separate receiver and method.

Mirrors Macro.decompose_call/1.

Examples

iex> call = {:function_call, [name: "add"], [{:variable, [], "x"}, {:variable, [], "y"}]}
iex> Metastatic.AST.decompose_call(call)
{"add", [{:variable, [], "x"}, {:variable, [], "y"}]}

iex> Metastatic.AST.decompose_call({:literal, [subtype: :integer], 42})
:error

@spec decorator(String.t(), [meta_ast()], keyword()) :: meta_ast()

Create a decorator node.

Examples

iex> Metastatic.AST.decorator("staticmethod")
{:decorator, [name: "staticmethod"], []}

iex> Metastatic.AST.decorator("app.route", [{:literal, [subtype: :string], "/api"}])
{:decorator, [name: "app.route"], [{:literal, [subtype: :string], "/api"}]}

@spec filter(
  meta_ast(),
  keyword()
) :: meta_ast()

Create a filter node.

Examples

iex> condition = {:binary_op, [category: :comparison, operator: :>], [{:variable, [], "x"}, {:literal, [subtype: :integer], 0}]}
iex> Metastatic.AST.filter(condition)
{:filter, [], [{:binary_op, [category: :comparison, operator: :>], [{:variable, [], "x"}, {:literal, [subtype: :integer], 0}]}]}

@spec function_call(String.t(), [meta_ast()], keyword()) :: meta_ast()

Create a function call node.

Examples

iex> args = [{:variable, [], "x"}, {:literal, [subtype: :integer], 5}]
iex> Metastatic.AST.function_call("add", args)
{:function_call, [name: "add"], [{:variable, [], "x"}, {:literal, [subtype: :integer], 5}]}

@spec function_def(String.t(), [term()], [meta_ast()], keyword()) :: meta_ast()

Create a function definition node.

Examples

iex> body = [{:binary_op, [category: :arithmetic, operator: :+],
...>   [{:variable, [], "x"}, {:variable, [], "y"}]}]
iex> Metastatic.AST.function_def("add", ["x", "y"], body)
{:function_def, [name: "add", params: [{:param, [], "x"}, {:param, [], "y"}]], [{:binary_op, [category: :arithmetic, operator: :+], [{:variable, [], "x"}, {:variable, [], "y"}]}]}

@spec function_name(meta_ast()) :: String.t() | nil

Extract the name from a function_def node.

Examples

iex> body = {:binary_op, [operator: :+], [{:variable, [], "x"}, {:variable, [], "y"}]}
iex> ast = {:function_def, [name: "add", params: [{:param, [], "x"}, {:param, [], "y"}]], [body]}
iex> Metastatic.AST.function_name(ast)
"add"

@spec function_visibility(meta_ast()) :: visibility()

Get the visibility of a function_def node.

Examples

iex> body = {:binary_op, [operator: :+], [{:variable, [], "x"}, {:variable, [], "y"}]}
iex> ast = {:function_def, [name: "add", visibility: :public], [body]}
iex> Metastatic.AST.function_visibility(ast)
:public

@spec generator(meta_ast(), meta_ast(), keyword()) :: meta_ast()

Create a generator node.

Examples

iex> var = {:variable, [], "x"}
iex> coll = {:function_call, [name: "range"], [{:literal, [subtype: :integer], 10}]}
iex> Metastatic.AST.generator(var, coll)
{:generator, [], [{:variable, [], "x"}, {:function_call, [name: "range"], [{:literal, [subtype: :integer], 10}]}]}

@spec get_meta(meta_ast(), atom(), term()) :: term()

Get a specific metadata value by key.

Examples

iex> ast = {:literal, [subtype: :integer, line: 10], 42}
iex> Metastatic.AST.get_meta(ast, :line)
10

iex> ast = {:variable, [], "x"}
iex> Metastatic.AST.get_meta(ast, :line)
nil

iex> ast = {:variable, [], "x"}
iex> Metastatic.AST.get_meta(ast, :line, 0)
0

@spec has_state?(meta_ast()) :: boolean()

Check if a container has state (classes typically have state).

Examples

iex> ast = {:container, [container_type: :class, name: "Counter"], []}
iex> Metastatic.AST.has_state?(ast)
true

iex> ast = {:container, [container_type: :module, name: "Math"], []}
iex> Metastatic.AST.has_state?(ast)
false

@spec inline_match(meta_ast(), meta_ast(), keyword()) :: meta_ast()

Create an inline match node.

Examples

iex> pattern = {:variable, [], "x"}
iex> value = {:literal, [subtype: :integer], 42}
iex> Metastatic.AST.inline_match(pattern, value)
{:inline_match, [], [{:variable, [], "x"}, {:literal, [subtype: :integer], 42}]}

@spec layer(atom()) :: :core | :extended | :structural | :native | :unknown

Get the layer classification for a node type.

Returns :core, :extended, :structural, or :native.

Examples

iex> Metastatic.AST.layer(:literal)
:core

iex> Metastatic.AST.layer(:lambda)
:extended

iex> Metastatic.AST.layer(:container)
:structural

iex> Metastatic.AST.layer(:language_specific)
:native

@spec leaf?(meta_ast()) :: boolean()

Check if a node is a leaf node (no children to traverse).

Examples

iex> Metastatic.AST.leaf?({:literal, [subtype: :integer], 42})
true

iex> Metastatic.AST.leaf?({:variable, [], "x"})
true

iex> left = {:variable, [], "x"}
iex> right = {:literal, [subtype: :integer], 5}
iex> Metastatic.AST.leaf?({:binary_op, [], [left, right]})
false

@spec literal(literal_subtype(), term(), keyword()) :: meta_ast()

Create a literal node.

Examples

iex> Metastatic.AST.literal(:integer, 42)
{:literal, [subtype: :integer], 42}

iex> Metastatic.AST.literal(:string, "hello", line: 5)
{:literal, [subtype: :string, line: 5], "hello"}

@spec literal?(meta_ast()) :: boolean()

Returns true if the given MetaAST represents a literal value.

A node is considered literal if it is a :literal node, or a composite node (:list, :tuple, :map, :pair) whose children are all literals.

Mirrors Macro.quoted_literal?/1.

Examples

iex> Metastatic.AST.literal?({:literal, [subtype: :integer], 42})
true

iex> Metastatic.AST.literal?({:list, [], [{:literal, [subtype: :integer], 1}, {:literal, [subtype: :integer], 2}]})
true

iex> Metastatic.AST.literal?({:variable, [], "x"})
false

iex> Metastatic.AST.literal?({:list, [], [{:variable, [], "x"}]})
false

@spec location(meta_ast()) :: map() | nil

Extract location information from a MetaAST node.

Returns a map with :line, :col, :end_line, :end_col if present in metadata.

Examples

iex> ast = {:literal, [subtype: :integer, line: 10, col: 5], 42}
iex> Metastatic.AST.location(ast)
%{line: 10, col: 5}

iex> ast = {:variable, [], "x"}
iex> Metastatic.AST.location(ast)
nil

@spec map_node(
  [meta_ast()],
  keyword()
) :: meta_ast()

Create a map node with pairs.

Examples

iex> pairs = [Metastatic.AST.pair(
...>   {:literal, [subtype: :symbol], :name},
...>   {:literal, [subtype: :string], "Alice"})]
iex> Metastatic.AST.map_node(pairs)
{:map, [], [{:pair, [], [{:literal, [subtype: :symbol], :name}, {:literal, [subtype: :string], "Alice"}]}]}

@spec meta(meta_ast()) :: keyword()

Extract the metadata keyword list from a MetaAST node.

Examples

iex> Metastatic.AST.meta({:literal, [subtype: :integer, line: 10], 42})
[subtype: :integer, line: 10]

iex> Metastatic.AST.meta({:variable, [], "x"})
[]

@spec metadata(meta_ast()) :: keyword()

Extract all metadata from a MetaAST node as a keyword list.

Returns the full metadata including location, M1 context (module, function, arity, etc.), and node-specific metadata (subtype, operator, etc.).

Examples

iex> ast = {:literal, [subtype: :integer, line: 10], 42}
iex> Metastatic.AST.metadata(ast)
[subtype: :integer, line: 10]

iex> ast = {:variable, [line: 5, module: "MyApp", function: "create"], "x"}
iex> Metastatic.AST.metadata(ast)
[line: 5, module: "MyApp", function: "create"]

iex> ast = {:variable, [], "x"}
iex> Metastatic.AST.metadata(ast)
[]

@spec node_arity(meta_ast()) :: non_neg_integer() | nil

Extract arity from node metadata.

@spec node_container(meta_ast()) :: String.t() | nil

Extract container name from node metadata.

@spec node_file(meta_ast()) :: String.t() | nil

Extract file path from node metadata.

@spec node_function(meta_ast()) :: String.t() | nil

Extract function name from node metadata.

@spec node_module(meta_ast()) :: String.t() | nil

Extract module name from node metadata.

Examples

iex> ast = {:variable, [module: "MyApp.Controller"], "x"}
iex> Metastatic.AST.node_module(ast)
"MyApp.Controller"

@spec node_visibility(meta_ast()) :: visibility() | nil

Extract visibility from node metadata.

@spec operator?(meta_ast()) :: boolean()

Returns true if the node is a binary or unary operator.

Examples

iex> Metastatic.AST.operator?({:binary_op, [category: :arithmetic, operator: :+], [{:variable, [], "x"}, {:literal, [subtype: :integer], 1}]})
true

iex> Metastatic.AST.operator?({:unary_op, [category: :arithmetic, operator: :-], [{:variable, [], "x"}]})
true

iex> Metastatic.AST.operator?({:literal, [subtype: :integer], 42})
false

@spec pair(meta_ast(), meta_ast(), keyword()) :: meta_ast()

Create a key-value pair node for maps.

Examples

iex> key = {:literal, [subtype: :symbol], :name}
iex> value = {:literal, [subtype: :string], "Alice"}
iex> Metastatic.AST.pair(key, value)
{:pair, [], [{:literal, [subtype: :symbol], :name}, {:literal, [subtype: :string], "Alice"}]}

@spec path(meta_ast(), (meta_ast() -> as_boolean(term()))) :: [meta_ast()] | nil

Returns the path to the node in ast for which fun returns a truthy value.

The path is a list, starting with the node for which fun returns a truthy value, followed by all of its parents up to the root. Returns nil if no node matches.

Mirrors Macro.path/2.

Examples

iex> ast = {:binary_op, [category: :arithmetic, operator: :+],
...>   [{:variable, [], "x"}, {:literal, [subtype: :integer], 42}]}
iex> path = Metastatic.AST.path(ast, fn
...>   {:literal, _, 42} -> true
...>   _ -> false
...> end)
iex> Enum.map(path, &Metastatic.AST.type/1)
[:literal, :binary_op]

iex> ast = {:literal, [subtype: :integer], 1}
iex> Metastatic.AST.path(ast, fn {:variable, _, _} -> true; _ -> false end)
nil

@spec pipe(meta_ast(), meta_ast(), keyword()) :: meta_ast()

Create a pipe node.

Preserves the pipe operator (|>, ->, etc.) as a first-class node rather than desugaring it into a function call. Useful for languages where the pipe has distinct syntactic or semantic meaning.

Parameters

• left - Left-hand side of the pipe
• right - Right-hand side (function to pipe into)
• meta - Optional metadata (default: [operator: :|>])

Examples

iex> left = {:variable, [], "x"}
iex> right = {:function_call, [name: "inspect"], []}
iex> Metastatic.AST.pipe(left, right)
{:pipe, [operator: :|>], [{:variable, [], "x"}, {:function_call, [name: "inspect"], []}]}

@spec pipe_into(meta_ast(), meta_ast(), non_neg_integer()) :: meta_ast()

Pipes expr into the call_args at the given position.

Inserts expr as an argument into a function call node at the specified 0-indexed position. If call_args is a :function_call node, the expression is injected into its argument list.

Mirrors Macro.pipe/3.

Examples

iex> expr = {:variable, [], "x"}
iex> call = {:function_call, [name: "foo"], [{:literal, [subtype: :integer], 1}]}
iex> Metastatic.AST.pipe_into(expr, call, 0)
{:function_call, [name: "foo"], [{:variable, [], "x"}, {:literal, [subtype: :integer], 1}]}

@spec postwalk(meta_ast() | term(), (meta_ast() | term() -> meta_ast() | term())) ::
  meta_ast() | term()

Performs a depth-first, post-order traversal of the MetaAST.

Returns a new AST where each node is the result of invoking fun on each corresponding node. This is the transform-only variant (no accumulator), mirroring Macro.postwalk/2.

Examples

iex> ast = {:binary_op, [category: :arithmetic, operator: :+],
...>   [{:literal, [subtype: :integer], 1}, {:literal, [subtype: :integer], 2}]}
iex> Metastatic.AST.postwalk(ast, fn
...>   {:literal, meta, value} when is_integer(value) -> {:literal, meta, value * 10}
...>   node -> node
...> end)
{:binary_op, [category: :arithmetic, operator: :+],
  [{:literal, [subtype: :integer], 10}, {:literal, [subtype: :integer], 20}]}

@spec postwalk(meta_ast() | term(), acc, (meta_ast() | term(), acc ->
                                      {meta_ast() | term(), acc})) ::
  {meta_ast() | term(), acc}
when acc: term()

Traverse a MetaAST with only a post function (pre is identity).

Examples

{new_ast, acc} = AST.postwalk(ast, [], fn node, acc -> {node, acc} end)

@spec postwalker(meta_ast()) :: Enumerable.t()

Returns an enumerable that traverses the MetaAST in depth-first, post-order.

Mirrors Macro.postwalker/1. The returned enumerable lazily yields each node after its children.

Examples

iex> ast = {:binary_op, [category: :arithmetic, operator: :+],
...>   [{:literal, [subtype: :integer], 1}, {:literal, [subtype: :integer], 2}]}
iex> ast |> Metastatic.AST.postwalker() |> Enum.map(&Metastatic.AST.type/1)
[:literal, :literal, :binary_op]

@spec prewalk(meta_ast() | term(), (meta_ast() | term() -> meta_ast() | term())) ::
  meta_ast() | term()

Performs a depth-first, pre-order traversal of the MetaAST.

Returns a new AST where each node is the result of invoking fun on each corresponding node. This is the transform-only variant (no accumulator), mirroring Macro.prewalk/2.

Examples

iex> ast = {:binary_op, [category: :arithmetic, operator: :+],
...>   [{:literal, [subtype: :integer], 1}, {:literal, [subtype: :integer], 2}]}
iex> Metastatic.AST.prewalk(ast, fn
...>   {:literal, meta, value} when is_integer(value) -> {:literal, meta, value * 10}
...>   node -> node
...> end)
{:binary_op, [category: :arithmetic, operator: :+],
  [{:literal, [subtype: :integer], 10}, {:literal, [subtype: :integer], 20}]}

@spec prewalk(meta_ast() | term(), acc, (meta_ast() | term(), acc ->
                                     {meta_ast() | term(), acc})) ::
  {meta_ast() | term(), acc}
when acc: term()

Traverse a MetaAST with only a pre function (post is identity).

Examples

{new_ast, acc} = AST.prewalk(ast, [], fn node, acc -> {node, acc} end)

@spec prewalker(meta_ast()) :: Enumerable.t()

Returns an enumerable that traverses the MetaAST in depth-first, pre-order.

Mirrors Macro.prewalker/1. The returned enumerable lazily yields each node before its children.

Examples

iex> ast = {:binary_op, [category: :arithmetic, operator: :+],
...>   [{:literal, [subtype: :integer], 1}, {:literal, [subtype: :integer], 2}]}
iex> ast |> Metastatic.AST.prewalker() |> Enum.map(&Metastatic.AST.type/1)
[:binary_op, :literal, :literal]

@spec put_meta(meta_ast(), atom(), term()) :: meta_ast()

Put a metadata value by key.

Examples

iex> ast = {:literal, [subtype: :integer], 42}
iex> Metastatic.AST.put_meta(ast, :line, 10)
{:literal, [line: 10, subtype: :integer], 42}

iex> ast = {:variable, [line: 5], "x"}
iex> Metastatic.AST.put_meta(ast, :line, 10)
{:variable, [line: 10], "x"}

@spec range(meta_ast(), meta_ast(), keyword()) :: meta_ast()

Create a range node.

Examples

iex> start = {:literal, [subtype: :integer], 1}
iex> stop = {:literal, [subtype: :integer], 10}
iex> Metastatic.AST.range(start, stop)
{:range, [], [{:literal, [subtype: :integer], 1}, {:literal, [subtype: :integer], 10}]}

iex> start = {:literal, [subtype: :integer], 1}
iex> stop = {:literal, [subtype: :integer], 10}
iex> step = {:literal, [subtype: :integer], 2}
iex> Metastatic.AST.range(start, stop, step: step)
{:range, [step: {:literal, [subtype: :integer], 2}], [{:literal, [subtype: :integer], 1}, {:literal, [subtype: :integer], 10}]}

@spec string_interpolation(
  [meta_ast()],
  keyword()
) :: meta_ast()

Create a string interpolation node.

Examples

iex> parts = [{:literal, [subtype: :string], "Hello, "}, {:variable, [], "name"}, {:literal, [subtype: :string], "!"}]
iex> Metastatic.AST.string_interpolation(parts)
{:string_interpolation, [], [{:literal, [subtype: :string], "Hello, "}, {:variable, [], "name"}, {:literal, [subtype: :string], "!"}]}

@spec throw_node(atom(), meta_ast() | nil, keyword()) :: meta_ast()

Create a throw/raise node.

Examples

iex> exception = {:function_call, [name: "ValueError"], [{:literal, [subtype: :string], "bad value"}]}
iex> Metastatic.AST.throw_node(:raise, exception)
{:throw, [kind: :raise], [{:function_call, [name: "ValueError"], [{:literal, [subtype: :string], "bad value"}]}]}

@spec to_string(meta_ast()) :: String.t()

Converts a MetaAST node to a human-readable string representation.

Produces a compact notation that conveys the structure without reproducing full Elixir tuple syntax. Useful for debugging and logging.

Mirrors Macro.to_string/1.

Examples

iex> Metastatic.AST.to_string({:literal, [subtype: :integer], 42})
"42"

iex> Metastatic.AST.to_string({:variable, [], "x"})
"x"

iex> ast = {:binary_op, [category: :arithmetic, operator: :+],
...>   [{:variable, [], "x"}, {:literal, [subtype: :integer], 5}]}
iex> Metastatic.AST.to_string(ast)
"x + 5"

iex> ast = {:function_call, [name: "foo"], [{:variable, [], "x"}, {:literal, [subtype: :integer], 1}]}
iex> Metastatic.AST.to_string(ast)
"foo(x, 1)"

iex> ast = {:list, [], [{:literal, [subtype: :integer], 1}, {:literal, [subtype: :integer], 2}]}
iex> Metastatic.AST.to_string(ast)
"[1, 2]"

@spec traverse(meta_ast() | term(), acc, pre_fun, post_fun) ::
  {meta_ast() | term(), acc}
when acc: term(),
     pre_fun: (meta_ast() | term(), acc -> {meta_ast() | term(), acc}),
     post_fun: (meta_ast() | term(), acc -> {meta_ast() | term(), acc})

Traverse a MetaAST, applying pre and post functions.

This mirrors Macro.traverse/4 from Elixir's standard library.

• pre is called before visiting children, receives {ast, acc}, returns {ast, acc}
• post is called after visiting children, receives {ast, acc}, returns {ast, acc}

The traversal visits children based on the node type:

• Leaf nodes (literal, variable): No children to visit
• Composite nodes: Visits each child in the list
• Non-AST values: Passed through unchanged

Examples

# Count all nodes
{_ast, count} = AST.traverse(ast, 0, fn node, acc -> {node, acc + 1} end, fn node, acc -> {node, acc} end)

# Collect all variable names
{_ast, vars} = AST.traverse(ast, [], fn
  {:variable, _, name} = node, acc -> {node, [name | acc]}
  node, acc -> {node, acc}
end, fn node, acc -> {node, acc} end)

# Transform all integers by doubling them
{new_ast, _} = AST.traverse(ast, nil, fn node, acc -> {node, acc} end, fn
  {:literal, meta, value} = node, acc ->
    if Keyword.get(meta, :subtype) == :integer do
      {{:literal, meta, value * 2}, acc}
    else
      {node, acc}
    end
  node, acc -> {node, acc}
end)

@spec type(meta_ast()) :: atom()

Extract the node type from a MetaAST node.

Examples

iex> Metastatic.AST.type({:literal, [subtype: :integer], 42})
:literal

iex> left = {:variable, [], "x"}
iex> right = {:literal, [subtype: :integer], 5}
iex> Metastatic.AST.type({:binary_op, [operator: :+], [left, right]})
:binary_op

@spec type_annotation(atom(), meta_ast(), meta_ast(), keyword()) :: meta_ast()

Create a type annotation node.

Examples

iex> target = {:function_call, [name: "add"], []}
iex> type_expr = {:literal, [subtype: :string], "integer() :: integer() -> integer()"}
iex> Metastatic.AST.type_annotation(:spec, target, type_expr)
{:type_annotation, [annotation_type: :spec], [{:function_call, [name: "add"], []}, {:literal, [subtype: :string], "integer() :: integer() -> integer()"}]}