Merge branch 'main' into jv-opt-descr

Author: josevalim

.github/workflows/codeql.yml

@@ -32,12 +32,12 @@ jobs:
         with:
           persist-credentials: false
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5
+        uses: github/codeql-action/init@7211b7c8077ea37d8641b6271f6a365a22a5fbfa # v4.36.0
         with:
           languages: ${{ matrix.language }}
           build-mode: ${{ matrix.build-mode }}
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@9e0d7b8d25671d64c341c19c0152d693099fb5ba # v4.35.5
+        uses: github/codeql-action/analyze@7211b7c8077ea37d8641b6271f6a365a22a5fbfa # v4.36.0
         with:
           category: "/language:${{matrix.language}}"
 

lib/eex/lib/eex/compiler.ex

@@ -79,15 +79,15 @@ defmodule EEx.Compiler do
         {:error, message <> code_snippet(state.source, state.indentation, meta), meta}
 
       {:ok, expr, new_line, new_column, rest} ->
-        {key, expr} =
+        {key, expr, extra_meta} =
           case :elixir_tokenizer.tokenize(expr, 1, file: "eex", check_terminators: false) do
             {:ok, _line, _column, _warnings, rev_tokens, []} ->
               # We ignore warnings because the code will be tokenized
               # again later with the right line+column info
               token_key(rev_tokens, expr)
 
             {:error, _, _, _, _} ->
-              {:expr, expr}
+              {:expr, expr, %{}}
           end
 
         marker =
@@ -102,8 +102,8 @@ defmodule EEx.Compiler do
             marker
           end
 
-        token = {key, marker, expr, %{line: line, column: column}}
-        trim_and_tokenize(rest, new_line, new_column, state, buffer, acc, &[token | &1])
+        token = {key, marker, expr, Map.merge(%{line: line, column: column}, extra_meta)}
+        trim_and_tokenize(rest, new_line, new_column, state, buffer, acc, &merge_token(token, &1))
     end
   end
 
@@ -127,6 +127,27 @@ defmodule EEx.Compiler do
     tokenize(rest, line, column, state, [{line, column}], fun.(acc))
   end
 
+  # Merge middle expressions separated only by whitespace so the whitespace is
+  # part of the Elixir expression, not a separate EEx body.
+  defp merge_token(
+         {:middle_expr, ~c"", chars, meta},
+         [{:text, text, text_meta}, {:middle_expr, ~c"", prev_chars, prev_meta} | acc]
+       ) do
+    if only_spaces?(text) and clause_block_identifier?(prev_meta) do
+      [{:middle_expr, ~c"", prev_chars ++ text ++ chars, prev_meta} | acc]
+    else
+      [
+        {:middle_expr, ~c"", chars, meta},
+        {:text, text, text_meta},
+        {:middle_expr, ~c"", prev_chars, prev_meta} | acc
+      ]
+    end
+  end
+
+  defp merge_token(token, acc) do
+    [token | acc]
+  end
+
   # Retrieve marker for <%
 
   defp retrieve_marker([marker | t]) when marker in [?=, ?/, ?|] do
@@ -177,31 +198,31 @@ defmodule EEx.Compiler do
   defp token_key(rev_tokens, expr) do
     case {Enum.reverse(rev_tokens), drop_eol(rev_tokens)} do
       {[{:end, _} | _], [{:do, _} | _]} ->
-        {:middle_expr, expr}
+        {:middle_expr, expr, %{}}
 
       {_, [{:do, _} | _]} ->
-        {:start_expr, maybe_append_space(expr)}
+        {:start_expr, maybe_append_space(expr), %{}}
 
-      {_, [{:block_identifier, _, _} | _]} ->
-        {:middle_expr, maybe_append_space(expr)}
+      {_, [{:block_identifier, _, identifier} | _]} ->
+        {:middle_expr, maybe_append_space(expr), %{block_identifier: identifier}}
 
       {[{:end, _} | _], [{:stab_op, _, _} | _]} ->
-        {:middle_expr, expr}
+        {:middle_expr, expr, %{}}
 
       {_, [{:stab_op, _, _} | reverse_tokens]} ->
         fn_index = Enum.find_index(reverse_tokens, &match?({:fn, _}, &1)) || :infinity
         end_index = Enum.find_index(reverse_tokens, &match?({:end, _}, &1)) || :infinity
 
         if end_index > fn_index do
-          {:start_expr, expr}
+          {:start_expr, expr, %{}}
         else
-          {:middle_expr, expr}
+          {:middle_expr, expr, %{}}
         end
 
       {tokens, _} ->
         case Enum.drop_while(tokens, &closing_bracket?/1) do
-          [{:end, _} | _] -> {:end_expr, expr}
-          _ -> {:expr, expr}
+          [{:end, _} | _] -> {:end_expr, expr, %{}}
+          _ -> {:expr, expr, %{}}
         end
     end
   end
@@ -476,6 +497,12 @@ defmodule EEx.Compiler do
     Enum.all?(chars, &(&1 in @all_spaces))
   end
 
+  defp clause_block_identifier?(%{block_identifier: identifier}) do
+    identifier in [:else, :rescue, :catch]
+  end
+
+  defp clause_block_identifier?(_meta), do: false
+
   # Changes placeholder to real expression
 
   defp insert_quoted({:__EEX__, _, [key]}, quoted) do

lib/eex/test/eex/tokenizer_test.exs

@@ -270,7 +270,7 @@ defmodule EEx.TokenizerTest do
       {:text, ~c"foo ", %{column: 1, line: 1}},
       {:start_expr, ~c"", ~c" if true do ", %{column: 5, line: 1}},
       {:text, ~c"bar", %{column: 21, line: 1}},
-      {:middle_expr, ~c"", ~c" else ", %{column: 24, line: 1}},
+      {:middle_expr, ~c"", ~c" else ", %{block_identifier: :else, column: 24, line: 1}},
       {:text, ~c"baz", %{column: 34, line: 1}},
       {:end_expr, ~c"", ~c" end ", %{column: 37, line: 1}},
       {:eof, %{column: 46, line: 1}}
@@ -286,7 +286,7 @@ defmodule EEx.TokenizerTest do
     exprs = [
       {:start_expr, ~c"=", ~c" if true do ", %{column: 2, line: 1}},
       {:text, ~c"\n TRUE \n", %{column: 20, line: 1}},
-      {:middle_expr, ~c"", ~c" else ", %{column: 3, line: 3}},
+      {:middle_expr, ~c"", ~c" else ", %{block_identifier: :else, column: 3, line: 3}},
       {:text, ~c"\n FALSE \n", %{column: 13, line: 3}},
       {:end_expr, ~c"", ~c" end ", %{column: 3, line: 5}},
       {:eof, %{column: 3, line: 7}}

lib/eex/test/eex_test.exs

@@ -262,6 +262,37 @@ defmodule EExTest do
       assert_eval("foo 1,2,3", "foo <% require Enum, as: E %><%= E.join [1, 2, 3], \",\" %>")
     end
 
+    test "with expression with else clause split across tags" do
+      template = """
+      <%= with {:ok, x} <- @res do %>
+        <p><%= x %></p>
+      <% else %>
+        <% _ -> %>
+          <p>bad</p>
+      <% end %>
+      """
+
+      assert_eval("\n  <p>ok</p>\n\n", template, [assigns: [res: {:ok, "ok"}]],
+        engine: EEx.SmartEngine
+      )
+
+      assert_eval("\n    <p>bad</p>\n\n", template, [assigns: [res: :error]],
+        engine: EEx.SmartEngine
+      )
+    end
+
+    test "empty clauses separated by whitespace" do
+      template = """
+      <%= case x do %>
+        <% :foo -> %>
+        <% :bar -> %>
+      <% end %>
+      """
+
+      assert_eval("\n  \n", template, x: :foo)
+      assert_eval("\n\n", template, x: :bar)
+    end
+
     test "with end of token" do
       assert_eval("foo bar %>", "foo bar %>")
     end
@@ -522,7 +553,7 @@ defmodule EExTest do
 
       assert message |> Exception.message() |> strip_ansi() =~ """
                   │
-              514 │                   true && @some[\s
+              #{line + 2} │                   true && @some[\s
                   │                                │ └ missing closing delimiter (expected "]")
                   │                                └ unclosed delimiter
              """

lib/elixir/lib/calendar.ex

@@ -3,6 +3,8 @@
 # SPDX-FileCopyrightText: 2012 Plataformatec
 
 defmodule Calendar do
+  @strftime_max_width 1024
+
   @moduledoc """
   This module defines the responsibilities for working with
   calendars, dates, times and datetimes in Elixir.
@@ -529,6 +531,7 @@ defmodule Calendar do
     * `%`: indicates the start of a formatted section
     * `<padding>`: set the padding (see below)
     * `<width>`: a number indicating the minimum size of the formatted section
+      (maximum #{@strftime_max_width})
     * `<format>`: the format itself (see below)
 
   ### Accepted padding options
@@ -667,9 +670,13 @@ defmodule Calendar do
   end
 
   defp parse_modifiers(<<digit, rest::binary>>, width, pad, parser_data) when digit in ?0..?9 do
-    new_width = (width || 0) * 10 + (digit - ?0)
+    width = (width || 0) * 10 + (digit - ?0)
+
+    if width > @strftime_max_width do
+      raise ArgumentError, "invalid strftime format: width must be at most #{@strftime_max_width}"
+    end
 
-    parse_modifiers(rest, new_width, pad, parser_data)
+    parse_modifiers(rest, width, pad, parser_data)
   end
 
   # set default padding if none was specified

lib/elixir/lib/code.ex

@@ -314,7 +314,7 @@ defmodule Code do
     :relative_paths
   ]
 
-  @list_compiler_options [:tracers, :parser_options]
+  @list_compiler_options [:tracers, :parser_options, :erlc_options]
 
   @available_compiler_options @boolean_compiler_options ++
                                 @list_compiler_options ++
@@ -1634,13 +1634,19 @@ defmodule Code do
         nil
 
       :proceed ->
-        loaded =
-          Module.ParallelChecker.verify(fn ->
-            :elixir_compiler.string(charlist, file, fn _, _ -> :ok end)
-          end)
-
-        :elixir_code_server.cast({:required, file})
-        loaded
+        try do
+          loaded =
+            Module.ParallelChecker.verify(fn ->
+              :elixir_compiler.string(charlist, file, fn _, _ -> :ok end)
+            end)
+
+          :elixir_code_server.cast({:required, file})
+          loaded
+        catch
+          kind, reason ->
+            :elixir_code_server.call({:release, file})
+            :erlang.raise(kind, reason, __STACKTRACE__)
+        end
     end
   end
 
@@ -1753,6 +1759,10 @@ defmodule Code do
     * `:docs` - when `true`, retains documentation in the compiled module.
       Defaults to `true`.
 
+    * `:erlc_options` (since v1.21.0) - a list of Erlang compiler options. For example,
+      `erlc_options: [:beam_debug_info, :beam_debug_stack]` emits Erlang/OTP
+      debug metadata for BEAM debuggers. Defaults to `[]`.
+
     * `: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`.

lib/elixir/lib/code/fragment.ex

@@ -204,6 +204,7 @@ defmodule Code.Fragment do
           | {:local_arity, charlist}
           | {:local_call, charlist}
           | {:anonymous_call, inside_caller}
+          | {:capture_arg, charlist}
           | {:module_attribute, charlist}
           | {:operator, charlist}
           | {:operator_arity, charlist}

lib/elixir/lib/exception.ex

@@ -1046,7 +1046,7 @@ defmodule RuntimeError do
       iex> raise "oops!"
       ** (RuntimeError) oops!
 
-  You should use this exceptions sparingly, since most of the time it might be
+  You should use this exception sparingly, since most of the time it might be
   better to define your own exceptions specific to your application or library.
   Sometimes, however, there are situations in which you don't expect a condition to
   happen, but you want to give a meaningful error message if it does. In those cases,

lib/elixir/lib/kernel/typespec.ex

@@ -860,29 +860,29 @@ defmodule Kernel.Typespec do
     {{:type, location(meta), :nonempty_string, args}, state}
   end
 
-  defp typespec({type, _meta, []}, vars, caller, state) when type in [:charlist, :char_list] do
+  defp typespec({type, meta, []}, vars, caller, state) when type in [:charlist, :char_list] do
     if type == :char_list do
       warning = "the char_list() type is deprecated, use charlist()"
       IO.warn(warning, caller)
     end
 
-    typespec(quote(do: :elixir.charlist()), vars, caller, state)
+    remote_typespec(:charlist, meta, [], vars, caller, state)
   end
 
-  defp typespec({:nonempty_charlist, _meta, []}, vars, caller, state) do
-    typespec(quote(do: :elixir.nonempty_charlist()), vars, caller, state)
+  defp typespec({:nonempty_charlist, meta, []}, vars, caller, state) do
+    remote_typespec(:nonempty_charlist, meta, [], vars, caller, state)
   end
 
-  defp typespec({:struct, _meta, []}, vars, caller, state) do
-    typespec(quote(do: :elixir.struct()), vars, caller, state)
+  defp typespec({:struct, meta, []}, vars, caller, state) do
+    remote_typespec(:struct, meta, [], vars, caller, state)
   end
 
-  defp typespec({:as_boolean, _meta, [arg]}, vars, caller, state) do
-    typespec(quote(do: :elixir.as_boolean(unquote(arg))), vars, caller, state)
+  defp typespec({:as_boolean, meta, [arg]}, vars, caller, state) do
+    remote_typespec(:as_boolean, meta, [arg], vars, caller, state)
   end
 
-  defp typespec({:keyword, _meta, args}, vars, caller, state) when length(args) <= 1 do
-    typespec(quote(do: :elixir.keyword(unquote_splicing(args))), vars, caller, state)
+  defp typespec({:keyword, meta, args}, vars, caller, state) when length(args) <= 1 do
+    remote_typespec(:keyword, meta, args, vars, caller, state)
   end
 
   defp typespec({:fun, meta, args}, vars, caller, state) do
@@ -1007,6 +1007,10 @@ defmodule Kernel.Typespec do
     {{:remote_type, location(meta), [remote, name, args]}, state}
   end
 
+  defp remote_typespec(name, meta, args, vars, caller, state) do
+    typespec({{:., meta, [:elixir, name]}, meta, args}, vars, caller, state)
+  end
+
   defp collect_union({:|, _, [a, b]}), do: [a | collect_union(b)]
   defp collect_union(v), do: [v]
 

lib/elixir/lib/module/types/apply.ex

@@ -38,7 +38,9 @@ defmodule Module.Types.Apply do
   end
 
   fas = list(tuple([atom(), integer()]))
-  struct_info = list(closed_map(default: if_set(term()), field: atom()))
+
+  struct_info =
+    list(closed_map(default: if_set(term()), field: atom(), required: if_set(boolean())))
 
   shared_info = [
     attributes: list(tuple([atom(), list(term())])),