Fix quoting

Author: ggVGc

lib/elixir/lib/module/types/expr.ex

@@ -522,6 +522,10 @@ defmodule Module.Types.Expr do
     end
   end
 
+  def of_expr(node, expected, expr, stack, context) do
+    Module.Types.Literal.of_expr(node, expected, expr, stack, context)
+  end
+
   ## Tuples
 
   defp of_tuple(elems, _expected, expr, %{mode: :traversal} = stack, context) do

lib/elixir/lib/module/types/literal.ex

@@ -0,0 +1,14 @@
+defmodule Module.Types.Literal do
+  import Module.Types.Descr
+
+  def of_expr({tag, _meta, _bracket_type, _args}, _expected, _expr, _stack, context)
+      when tag in [
+             :sequence_block,
+             :sequence_literal,
+             :sequence_paren,
+             :sequence_brace,
+             :sequence_bracket
+           ] do
+    {dynamic(), context}
+  end
+end

lib/elixir/src/elixir_expand.erl

@@ -556,8 +556,11 @@ expand(Pid, S, E) when is_pid(Pid) ->
       {Pid, S, E}
   end;
 
-expand(Other, _S, E) ->
-  file_error([{line, 0}], ?key(E, file), ?MODULE, {invalid_quoted_expr, Other}).
+expand(Node, S, E) ->
+  case elixir_literal:expand(Node, S, E) of
+    false -> file_error([{line, 0}], ?key(E, file), ?MODULE, {invalid_quoted_expr, Node});
+    Result -> Result
+  end.
 
 %% Helpers
 
@@ -1291,4 +1294,4 @@ format_error({parens_map_lookup, Map, Field, Context}) ->
 format_error({super_in_genserver, {Name, Arity}}) ->
   io_lib:format("calling super for GenServer callback ~ts/~B is deprecated", [Name, Arity]);
 format_error('__cursor__') ->
-  "reserved special form __cursor__ cannot be expanded, it is used exclusively to annotate ASTs".
+  "reserved special form __cursor__ cannot be expanded, it is used exclusively to annotate ASTs".

lib/elixir/src/elixir_literal.erl

@@ -0,0 +1,54 @@
+%% Module for handling sequence literal AST nodes
+%% This module centralizes all sequence-related logic for the Elixir compiler
+-module(elixir_literal).
+
+-export([is_sequence_node/1, is_valid_ast/1, quote_node/2, escape_node/2, expand/3]).
+
+%% Check if a node is a sequence node
+is_sequence_node({sequence_block, _Meta, _BracketType, _Args}) -> true;
+is_sequence_node({sequence_literal, _Meta, _Args}) -> true;
+is_sequence_node({sequence_paren, _Meta, _Args}) -> true;
+is_sequence_node({sequence_bracket, _Meta, _Args}) -> true;
+is_sequence_node({sequence_brace, _Meta, _Args}) -> true;
+is_sequence_node(_) -> false.
+
+%% Validate sequence AST nodes
+%% For sequence_block (4-tuple format), validate the inner args
+is_valid_ast({sequence_block, Meta, BracketType, Args})
+  when is_list(Meta), is_atom(BracketType), is_list(Args) ->
+    % For sequence_block, we assume the args are valid since they will be processed by Paxir
+    true;
+%% For other sequence nodes (3-tuple format), they're always valid
+is_valid_ast({sequence_literal, Meta, Args})
+  when is_list(Meta), is_list(Args) -> true;
+is_valid_ast({sequence_paren, Meta, Args})
+  when is_list(Meta), is_list(Args) -> true;
+is_valid_ast({sequence_bracket, Meta, Args})
+  when is_list(Meta), is_list(Args) -> true;
+is_valid_ast({sequence_brace, Meta, Args})
+  when is_list(Meta), is_list(Args) -> true;
+is_valid_ast(_) -> false.
+
+%% Quote sequence nodes - keep them as-is without transforming internals
+quote_node({sequence_block, _Meta, _BracketType, _Args} = Node, _Q) -> Node;
+quote_node({sequence_literal, _Meta, _Args} = Node, _Q) -> Node;
+quote_node({sequence_paren, _Meta, _Args} = Node, _Q) -> Node;
+quote_node({sequence_bracket, _Meta, _Args} = Node, _Q) -> Node;
+quote_node({sequence_brace, _Meta, _Args} = Node, _Q) -> Node;
+quote_node(_, _) -> false.
+
+%% Escape sequence nodes - keep them as-is without transforming internals
+escape_node({sequence_block, _Meta, _BracketType, _Args} = Node, _Q) -> Node;
+escape_node({sequence_literal, _Meta, _Args} = Node, _Q) -> Node;
+escape_node({sequence_paren, _Meta, _Args} = Node, _Q) -> Node;
+escape_node({sequence_bracket, _Meta, _Args} = Node, _Q) -> Node;
+escape_node({sequence_brace, _Meta, _Args} = Node, _Q) -> Node;
+escape_node(_, _) -> false.
+
+%% Expand sequence nodes - keep them as-is since they will be processed by Paxir
+expand({sequence_block, _Meta, _BracketType, _Args} = Node, S, E) -> {Node, S, E};
+expand({sequence_literal, _Meta, _Args} = Node, S, E) -> {Node, S, E};
+expand({sequence_paren, _Meta, _Args} = Node, S, E) -> {Node, S, E};
+expand({sequence_bracket, _Meta, _Args} = Node, S, E) -> {Node, S, E};
+expand({sequence_brace, _Meta, _Args} = Node, S, E) -> {Node, S, E};
+expand(_, _, _) -> false.

lib/elixir/src/elixir_quote.erl

@@ -195,8 +195,11 @@ do_escape(Fun, _) when is_function(Fun) ->
     false -> bad_escape(Fun)
   end;
 
-do_escape(Other, _) ->
-  bad_escape(Other).
+do_escape(Node, Q) ->
+  case elixir_literal:escape_node(Node, Q) of
+    false -> bad_escape(Node);
+    Result -> Result
+  end.
 
 escape_map_key_value(K, V, Map, Q) ->
   MaybeRef = if
@@ -305,7 +308,9 @@ valid_ast_elem(Expr) when is_list(Expr); is_atom(Expr); is_binary(Expr); is_numb
 valid_ast_elem({Left, Right}) -> valid_ast_elem(Left) andalso valid_ast_elem(Right);
 valid_ast_elem({Atom, Meta, Args}) when is_atom(Atom), is_list(Meta), is_atom(Args) orelse is_list(Args) -> true;
 valid_ast_elem({Call, Meta, Args}) when is_list(Meta), is_list(Args) -> shallow_valid_ast(Call);
-valid_ast_elem(_Term) -> false.
+%% Support sequence nodes - delegate to elixir_literal module
+valid_ast_elem(Node) ->
+  elixir_literal:is_valid_ast(Node).
 
 quote({unquote_splicing, _, [_]}, #elixir_quote{unquote=true}) ->
   argument_error(<<"unquote_splicing only works inside arguments and block contexts, "
@@ -447,8 +452,11 @@ do_quote([H | T], #elixir_quote{unquote=false} = Q) ->
 do_quote([H | T], Q) ->
   do_quote_tail(lists:reverse(T, [H]), Q);
 
-do_quote(Other, _) ->
-  Other.
+do_quote(Node, Q) ->
+  case elixir_literal:quote_node(Node, Q) of
+    false -> Node;
+    Result -> Result
+  end.
 
 import_meta(Meta, Name, Arity, Q, E) ->
   case (keyfind(imports, Meta) == false) andalso

lib/elixir/test/elixir/kernel/parser_sequence_literal_test.exs

@@ -355,7 +355,7 @@ defmodule Kernel.ParserSequenceLiteralTest do
     end
 
     test "comments with different token types" do
-      # Comments should work with numbers and atoms  
+      # Comments should work with numbers and atoms
       result_with_comment = parse!("~~(42 # comment\n:atom)")
       result_without_comment = parse!("~~(42\n:atom)")
 
@@ -438,16 +438,79 @@ defmodule Kernel.ParserSequenceLiteralTest do
     test "comments at different positions in multiline sequence literals" do
       # Test comments at various positions to isolate the issue
 
-      # Comment at the beginning - this might work
       result1 = parse!("# comment before\n~~(valid code)")
       assert {:sequence_literal, [line: 2], _} = result1
 
-      # Comment at the end - this might work  
       result2 = parse!("~~(valid code)\n# comment after")
       assert {:sequence_literal, [line: 1], _} = result2
     end
   end
 
+  describe "sequence blocks in quote expressions" do
+    test "sequence_block nodes with tuple destructuring patterns compile correctly" do
+      # This test reproduces the issue where sequence_block nodes with tuple patterns
+      # inside quoted expressions fail to compile
+
+      # The issue occurs when we have a nested structure like:
+      # {:sequence_block, meta, :"()", [{:sequence_block, meta2, :{}, [elements]}]}
+      # This represents something like ({a b}) in the sequence literal
+
+      ast =
+        {:sequence_literal, [line: 1],
+         [
+           {:sequence_paren, [line: 1],
+            [
+              {:def, [line: 1], nil},
+              {:match_tuple, [line: 1], nil},
+              {:sequence_block, [line: 1, column: 24], :"()",
+               [
+                 {:sequence_block, [line: 1, column: 25], :{},
+                  [
+                    {:a, [line: 1, column: 26], nil},
+                    {:b, [line: 1, column: 28], nil}
+                  ]}
+               ]},
+              {:a, [line: 1], nil}
+            ]}
+         ]}
+
+      # This should not raise an error when used in a quote block
+      result =
+        quote do
+          unquote(ast)
+        end
+
+      # Verify the AST is preserved correctly
+      assert {:sequence_literal, _, _} = result
+    end
+
+    test "sequence_block with parentheses type compiles in quote" do
+      # Test that sequence_block with :"()" type works in quote expressions
+      ast = {:sequence_block, [line: 1], :"()", [{:a, [line: 1], nil}]}
+
+      # Should not raise an error
+      result =
+        quote do
+          unquote(ast)
+        end
+
+      assert {:sequence_block, _, :"()", _} = result
+    end
+
+    test "sequence_block with braces type compiles in quote" do
+      # Test that sequence_block with :{} type works in quote expressions
+      ast = {:sequence_block, [line: 1], :{}, [{:x, [line: 1], nil}, {:y, [line: 1], nil}]}
+
+      # Should not raise an error
+      result =
+        quote do
+          unquote(ast)
+        end
+
+      assert {:sequence_block, _, :{}, _} = result
+    end
+  end
+
   describe "tokenizer behavior verification" do
     # These tests verify that our tokenizer produces the expected token types
 
@@ -534,7 +597,6 @@ defmodule Kernel.ParserSequenceLiteralTest do
           _ -> false
         end)
 
-      # Should have sequence_end token  
       has_end =
         Enum.any?(tokens, fn
           {:sequence_end, {_, _, _}, :")"} -> true