Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

chore(deps): update dependency elixir to v1.18.0 #214

Open
wants to merge 1 commit into
base: main
Choose a base branch
from

Conversation

renovate[bot]
Copy link

@renovate renovate bot commented Nov 20, 2022

This PR contains the following updates:

Package Update Change
elixir (source) minor 1.13.2-otp-24 -> 1.18.0

Release Notes

elixir-lang/elixir (elixir)

v1.18.0

Compare Source

https://elixir-lang.org/blog/2024/12/19/elixir-v1-18-0-released/

Elixir v1.18 is an impressive release with improvements across the two main efforts happening within the Elixir ecosystem right now: set-theoretic types and language servers. It also comes with built-in JSON support and adds new capabilities to its unit testing library. Here is a quick break down.

Type system improvements

The most exciting change in Elixir v1.18 is type checking of function calls, alongside gradual inference of patterns and return types. To understand how this will impact your programs, consider the following code in "lib/user.ex":

defmodule User do
  defstruct [:age, :car_choice]

  def drive(%User{age: age, car_choice: car}, car_choices) when age >= 18 do
    if car in car_choices do
      {:ok, car}
    else
      {:error, :no_choice}
    end
  end

  def drive(%User{}, _car_choices) do
    {:error, :not_allowed}
  end
end

Elixir's type system will infer that the drive/2 function expects a %User{} struct and returns either {:ok, dynamic()}, {:error, :no_choice}, or {:error, :not_allowed}.

Therefore, the following code in a separate module (either in a separate or the same file), should emit a violation, due to an invalid argument:

User.drive({:ok, %User{}}, car_choices)

Here is the warning:

    warning: incompatible types given to User.drive/2:

        User.drive({:ok, %User{age: nil, car_choice: nil}}, car_choices)

    given types:

        {:ok, %User{age: nil, car_choice: nil}}, empty_list()

    but expected one of:

        dynamic(%User{age: term(), car_choice: term()}), dynamic()

    where "car_choices" was given the type:
### type: empty_list()
### from: lib/foo.ex:21:17
        car_choices = []

    typing violation found at:
    │
 22 │     User.drive({:ok, %User{}}, car_choices)
    │          ~
    │
    └─ lib/foo.ex:22:10: Example.run/0

The mismatched arguments are shown in red, if your terminal supports ANSI coloring.

And the next snippet will warn because the :error clause will never match, as that's not a valid return type of the User.drive/2 call:

case User.drive(user, car_choices) do
  {:ok, car} -> car
  :error -> Logger.error("User cannot drive")
end

And here is the warning:

    warning: the following clause will never match:

        :error

    because it attempts to match on the result of:

        User.drive(user, car_choices)

    which has type:

        dynamic({:ok, term()} or {:error, :no_choice} or {:error, :not_allowed})

    typing violation found at:
    │
 26 │       :error -> Logger.error("User cannot drive")
    │       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    │
    └─ lib/foo.ex:26: Example.run/0

For more details on typing inference and the trade-offs made by the Elixir team, see our official documentation.

There are many other improvements to the type system, which we will go in detail within the official release. Meanwhile, here is a list summary of the overall improvements done to the type system:

  • Type inference of patterns (typing inference of guards will be part of an upcoming release)

  • Type checking of all language constructs, including local and remote calls, except for, with, and closures

  • Type checking of all functions inlined by the compiler found in Kernel

  • Type checking of all conversion functions inlined by the compiler

  • Support for tuples and lists as composite types as well as type checking of their basic operations

  • Detection of clauses and patterns that will never match from case, cond, and =

  • Detection of unused clauses in private functions

ExUnit improvements

ExUnit now supports parameterized tests to run the same test module multiple times under different parameters.

For example, Elixir ships a local, decentralized and scalable key-value process storage called Registry. The registry can be partitioned and its implementation differs depending if partitioning is enabled or not. Therefore, during tests, we want to ensure both modes are exercised. With Elixir v1.18, we can achieve this by writing:

defmodule Registry.Test do
  use ExUnit.Case,
    async: true,
    parameterize: [
      %{partitions: 1},
      %{partitions: 8}
    ]

### ... the actual tests ...
end

ExUnit parameterizes whole test modules. If your modules are configured to run concurrently, as above, so will the parameterized ones.

ExUnit also comes with the ability of specifying test groups. While ExUnit supports running tests concurrently, those tests must not have shared state between them. However, in large applications, it may be common for some tests to depend on some shared state, and other tests to depend on a completely separate state. For example, part of your tests may depend on Cassandra, while others depend on Redis. Prior to Elixir v1.18, these tests could not run concurrently, but in v1.18 they might as long as they are assigned to different groups. Tests modules within the same group do not run concurrently, but across groups, they might.

With features like async tests, suite partitioning, and now grouping, Elixir developers have plenty of flexibility to make the most use of their machine resources, both in development and in CI.

mix format --migrate

The mix format command now supports an explicit --migrate flag, which will convert constructs that have been deprecated in Elixir to their latest version. Because this flag rewrites the AST, it is not guaranteed the migrated format will always be valid when used in combination with macros that also perform AST rewriting.

As of this release, the following migrations are executed:

  • Normalize parens in bitstring modifiers - it removes unnecessary parentheses in known bitstring modifiers, for example <<foo::binary()>> becomes <<foo::binary>>, or adds parentheses for custom modifiers, where <<foo::custom_type>> becomes <<foo::custom_type()>>.

  • Charlists as sigils - formats charlists as ~c sigils, for example 'foo' becomes ~c"foo".

  • unless as negated ifs - rewrites unless expressions using if with a negated condition, for example unless foo do becomes if !foo do.

More migrations may be added in future releases.

JSON support

This release includes official support for JSON encoding and decoding.

Both encoder and decoder fully conform to RFC 8259 and ECMA 404 standards.

Encoding

Encoding can be done via JSON.encode!/1 and JSON.encode_to_iodata!/1 functions. The default encoding rules are applied as follows:

Elixir JSON
integer() | float() Number
true | false Boolean
nil Null
binary() String
atom() String
list() Array
%{binary() => _} Object
%{atom() => _} Object
%{integer() => _} Object

You may also implement the JSON.Encoder protocol for custom data structures. Elixir already implements the protocol for all Calendar types.

If you have a struct, you can derive the implementation of the JSON.Encoder by specifying which fields should be encoded to JSON:

  @&#8203;derive {JSON.Encoder, only: [...]}
  defstruct ...
Decoding

Decoding can be done via JSON.decode/2 and JSON.decode!/2 functions. The default decoding rules are applied as follows:

JSON Elixir
Number integer() | float()
Boolean true | false
Null nil
String binary()
Object %{binary() => _}

Language server listeners

4 months ago, we welcomed the Official Language Server team, with the goal of unifying the efforts behind code intelligence, tools, and editors in Elixir. Elixir v1.18 brings new features on this front by introducing locks and listeners to its compilation. Let's understand what it means.

At the moment, all language server implementations have their own compilation environment. This means that your project and dependencies during development are compiled once, for your own use, and then again for the language server. This duplicate effort could cause the language server experience to lag, when it could be relying on the already compiled artifacts of your project.

This release address by introducing a compiler lock, ensuring that only a single operating system process running Elixir compiles your project at a given moment, and by providing the ability for one operating system process to listen to the compilation results of others. In other words, different Elixir instances can now communicate over the same compilation build, instead of racing each other.

These enhancements do not only improve editor tooling, but they also directly benefit projects like IEx and Phoenix. For example, you can invoke IEx.configure(auto_reload: true) and IEx will automatically reload modules changed elsewhere, either by a separate terminal or your IDE.

Potential incompatibilities

This release no longer supports WERL (a graphical user interface on Windows used by Erlang 25 and earlier). For a better user experience on Windows terminals, use Erlang/OTP 26+ (this is also the last Elixir release to support Erlang/OTP 25).

Furthermore, in order to support inference of patterns, Elixir will raise if it finds recursive variable definitions. This means patterns that never match, such as this one, will no longer compile:

def foo(x = {:ok, y}, x = y)

However, recursion of root variables (where variables directly point to each other), will also fail to compile:

def foo(x = y, y = z, z = x)

While the definition above could succeed (as long as all three arguments are equal), the cycle is not necessary and could be removed, as below:

def foo(x = y, y = z, z)

You may also prefer to write using guards:

def foo(x, y, z) when x == y and y == z
1. Enhancements
Elixir
  • [CLI] Add experimental PowerShell scripts for elixir, elixirc, and mix on Windows. Those provide a safer entry point for running Elixir from other platforms
  • [Calendar] Add Duration.to_string/1
  • [Code] Support several migration options in Code.format_string!/2
  • [Code] Add parenthesis around -- and --- in Code.format_string!/2 to make precedence clearer
  • [Code] Include more metadata in Code.string_to_quoted/2 when token_metadata: true to help compute ranges from the AST
  • [Code.Fragment] Have :capture_arg as its own entry in Code.Fragment.surround_context/2
  • [Config] Add Config.read_config/1
  • [Enumerable] Add Enum.product_by/2 and Enum.sum_by/2
  • [Exception] Add MissingApplicationsError exception to denote missing applications
  • [JSON] Add a new JSON module with encoding and decoding functionality
  • [JSON] Implement JSON.Encoder for all Calendar types
  • [Kernel] Update source code parsing to match UTS #​55 latest recommendations. In particular, mixed script is allowed in identifiers as long as they are separate by underscores (_), such as http_сервер. Previously allowed highly restrictive identifiers, which mixed Latin and other scripts, such as the japanese word for t-shirt, Tシャツ, now require the underscore as well
  • [Kernel] Warn on bidirectional confusability in identifiers
  • [Kernel] Verify the type of the binary generators
  • [Kernel] Track the type of tuples in patterns and inside elem/2
  • [Kernel] Perform validation of root AST nodes in unquote and unquote_splicing to catch bugs earlier
  • [Kernel] Add source, behaviour, and record information to Docs chunk metadata
  • [Kernel] Support deterministic builds in tandem with Erlang by setting ERL_COMPILER_OPTIONS=deterministic. Keep in mind deterministic builds strip source and other compile time information, which may be relevant for programs
  • [Kernel] Allow aliases and imports to be enabled conditionally in module body
  • [List] Add List.ends_with?/2
  • [Macro] Improve dbg handling of if/2, with/1 and of code blocks
  • [Macro] Add Macro.struct_info!/2 to return struct information mirroring mod.__info__(:struct)
  • [Registry] Add Registry.lock/3 for local locking
  • [PartitionSupervisor] Add PartitionSupervisor.resize!/2 to resize the number of partitions in a supervisor (up to the limit it was started with)
  • [Process] Handle arbitrarily high integer values in Process.sleep/1
  • [Protocol] Add @undefined_impl_description to customize error message when an implementation is undefined
  • [Protocol] Add __deriving__/1 as optional macro callback to Protocol, no longer requiring empty implementations
  • [String] Inspect special whitespace and zero-width characters using their Unicode representation
  • [String] Update Unicode to 16.0
ExUnit
  • [ExUnit] Support parameterized tests on ExUnit.Case
  • [ExUnit] Support test groups: tests in the same group never run concurrently
  • [ExUnit.Case] Add test_pid as a tag
IEx
  • [IEx] Add IEx.configure(auto_reload: true) to automatically pick up modules recompiled from other operating system processes
  • [IEx] Add :dot_iex support to IEx.configure/1
  • [IEx] Add report for normal/shutdown exits in IEx
Mix
  • [mix compile] Ensure only a single operating system process can compile at a given time
  • [mix deps.get] Ensure only a single operating system process can fetch deps at a given time
  • [mix format] Add mix format --migrate to migrate from deprecated functionality
  • [mix format] Add new options and metadata to improve formatting applying by editors and other environments
  • [mix test] Taint failure manifest if requiring or compiling tests fail
  • [Mix.Project] Add a :listeners configuration to listen to compilation events from the current and other operating system processes
  • [Mix.Task.Compiler] Add API for fetching all persisted compiler diagnostics
  • [Mix.Task.Compiler] Add API for fetching all compiler tasks
2. Bug fixes
Elixir
  • [Code] Fix delimiter metadata for single quoted atoms and remote calls in Code.string_to_quoted/2
  • [Code.Formatter] Fix formatter adding extra escapes to quoted remote calls
  • [Code.Fragment] Properly handle keyword keys as their own entry
  • [Inspect.Algebra] Ensure next_break_fits respects line_length
  • [Kernel] Validate AST on unquote and unquote_splicing to provide better error reports instead of failing too late inside the compiler
  • [Kernel] Avoid crashes when emitting diagnostics on code using \t for indentation
  • [Module] Include module attribute line and name when tracing its aliases
  • [Stream] Do not halt streams twice in Stream.transform/5
  • [URI] Fix a bug when a schemaless URI is given to URI.merge/2
ExUnit
  • [ExUnit.Assertions] Raise if guards are used in assert/1 with =
  • [ExUnit.Assertions] Format inserted/deleted maps in list assertions
IEx
  • [IEx.Helpers] IEx.Helpers.recompile/0 will reload modules changed by other operating system processes
Mix
  • [mix compile] Ensure warnings from external resources are emitted with --all-warnings when files do not change
  • [mix deps.compile] Fix escaping issues when invoking rebar3 in some cases
  • [mix escript] Fix escript layout and support storing priv directories
  • [mix release] Make .app files deterministic in releases
  • [Mix.Shell] Fix Mix.Shell on Windows when outputting non UTF-8 characters
3. Soft deprecations (no warnings emitted)
Elixir
  • [Inspect.Algebra] color/3 is deprecated in favor of color_doc/3
  • [Inspect.Algebra] fold_doc/2 is deprecated in favor of fold/2
  • [Kernel] Deprecate unless in favor of if. Use mix format --migrate to automate the migration
  • [Macro] Macro.struct!/2 is deprecated in favor of Macro.struct_info!/2
  • [Protocol] Defining __deriving__/3 inside the Any implementation is deprecated, derive it inside the protocol definition itself
4. Hard deprecations
EEx
  • [EEx] <%# is deprecated in favor of <%!-- or <% #
  • [EEx] c:EEx.handle_text/2 is deprecated in favor of c:EEx.handle_text/3
Elixir
  • [Code] Setting :warnings_as_errors is deprecated via Code.put_compiler_option/2. This must not affect developers, as the :warnings_as_errors option is managed by Mix tasks, and not directly used via the Code module
  • [Enumerable] Deprecate returning a two-arity function in Enumerable.slice/1
  • [List] List.zip/1 is deprecated in favor of Enum.zip/1
  • [Module] Deprecate Module.eval_quoted/3 in favor of Code.eval_quoted/3
  • [Range] Deprecate inferring negative ranges on Range.new/2
  • [Tuple] Tuple.append/2 is deprecated, use Tuple.insert_at/3 instead
Mix
  • [mix cmd] Deprecate mix cmd --app APP in favor of mix do --app APP
  • [mix compile] :warnings_as_errors configuration in :elixirc_options is deprecated. Instead pass the --warnings-as-errors flag to mix compile. Alternatively, you might alias the task: aliases: [compile: "compile --warnings-as-errors"]
  • [mix test] :warnings_as_errors configuration in :test_elixirc_options is deprecated. Instead pass the --warnings-as-errors flag to mix test. Alternatively, you might alias the task: aliases: [test: "test --warnings-as-errors"]
  • [Mix.Tasks.Compile] Deprecate compilers/0 in favor of Mix.Task.Compiler.compilers/0

v1.17

The CHANGELOG for v1.17 releases can be found in the v1.17 branch.

v1.17.3

Compare Source

1. Bug fixes
Elixir
  • [Duration] Fix parsing of fractional durations with non-positive seconds
  • [Kernel] Do not attempt to group module warnings when they have a large context
IEx
  • [IEx.Helpers] Properly reconsolidate protocols on recompile
Mix
  • [mix compile.elixir] Do not verify modules twice
  • [mix xref] Respect the --label option on stats and cycles

v1.17.2

Compare Source

1. Bug fixes
Logger
  • [Logger.Translator] Fix logger crash when :gen_statem's format_status/2 returns non-tuple
Mix
  • [mix deps.get] Fix regression when fetching a git repository with a :ref
  • [mix release] Validate RELEASE_MODE and set ERRORLEVEL on .bat scripts
  • [mix release] Fix invalid example in code comment inside the generated vm.args.eex

v1.17.1

Compare Source

1. Enhancements
Mix
  • [mix compile.elixir] Do not run fixpoint computation on runtime dependencies. This should considerably improve compilation times for large projects when changing only one or two files
2. Bug fixes
EEx
  • [EEx] Do not warn for assignment with blocks in EEx
Elixir
  • [Kernel] Fix bug when using pinned variables inside with's else patterns
  • [Kernel] Fix Dialyzer error when with else clause is calling a no_return function
ExUnit
  • [ExUnit] Do not alternative sync/async suites on --repeat-until-failure

v1.17.0

Compare Source

https://elixir-lang.org/blog/2024/06/12/elixir-v1-17-0-released/

This release includes type inference of patterns to provide warnings for an initial set of constructs (binaries, maps, and atoms) within the same function. It also includes a new Duration data type to interact with Calendar types, support for Erlang/OTP 27, and many other improvements.

Warnings from gradual set-theoretic types

This release introduces gradual set-theoretic types to infer types from patterns and use them to type check programs, enabling the Elixir compiler to find faults and bugs in codebases without requiring changes to existing software. The underlying principles, theory, and roadmap of our work have been outlined in "The Design Principles of the Elixir Type System" by Giuseppe Castagna, Guillaume Duboc, José Valim.

At the moment, Elixir developers will interact with set-theoretic types only through warnings found by the type system. The current implementation models all data types in the language:

  • binary(), integer(), float(), pid(), port(), reference() - these types are indivisible. This means both 1 and 13 get the same integer() type.

  • atom() - it represents all atoms and it is divisible. For instance, the atom :foo and :hello_world are also valid (distinct) types.

  • map() and structs - maps can be "closed" or "open". Closed maps only allow the specified keys, such as %{key: atom(), value: integer()}. Open maps support any other keys in addition to the ones listed and their definition starts with ..., such as %{..., key: atom(), value: integer()}. Structs are closed maps with the __struct__ key.

  • tuple(), list(), and function() - currently they are modelled as indivisible types. The next Elixir versions will also introduce fine-grained support to them.

We focused on atoms and maps on this initial release as they are respectively the simplest and the most complex types representations, so we can stress the performance of the type system and quality of error messages. Modelling these types will also provide the most immediate benefits to Elixir developers. Assuming there is a variable named user, holding a %User{} struct with an address field, Elixir v1.17 will emit the following warnings at compile-time:

  • Pattern matching against a map or a struct that does not have the given key, such as %{adress: ...} = user (notice address vs adress)

  • Accessing a key on a map or a struct that does not have the given key, such as user.adress

  • Updating a struct or a map that does not define the given key, such as %{user | adress: ...}

  • Invoking a function on non-modules, such as user.address()

  • Capturing a function on non-modules, such as &user.address/0

  • Attempting to invoke to call an anonymous function without an actual function, such as user.()

  • Performing structural comparisons with structs, such as my_date < ~D[2010-04-17]

  • Performing structural comparisons between non-overlapping types, such as integer >= string

  • Building and pattern matching on binaries without the relevant specifiers, such as <<name>> (this warns because by default it expects an integer, it should have been <<name::binary>> instead)

  • Attempting to rescue an undefined exception or a struct that is not an exception

  • Accessing a field that is not defined in a rescued exception

These new warnings help Elixir developers find bugs earlier and give more confidence when refactoring code, especially around maps and structs. While some of these warnings were emitted in the past, they were discovered using syntax analysis. The new warnings are more reliable, precise, and with better error messages. Keep in mind, however, that the Elixir typechecker only infers types from patterns within the same function at the moment. Analysis from guards and across function boundaries will be added in future relases. For more details, see our new reference document on gradual set-theoretic types.

The type system was made possible thanks to a partnership between CNRS and Remote. The development work is currently sponsored by Fresha, Starfish*, and Dashbit.

Erlang/OTP support

This release adds support for Erlang/OTP 27 and drops support for Erlang/OTP 24. We recommend Elixir developers to migrate to Erlang/OTP 26 or later, especially on Windows. Support for WERL (a graphical user interface for the Erlang terminal on Windows) will be removed in Elixir v1.18.

Adding Duration and shift/2 functions

Elixir introduces the Duration data type and APIs to shift dates, times, and date times by a given duration, considering different calendars and time zones.

iex> Date.shift(~D[2016-01-31], month: 2)
~D[2016-03-31]

Note the operation is called shift (instead of add) since working with durations does not obey properties such as associativity. For instance, adding one month and then one month does not give the same result as adding two months:

iex> ~D[2016-01-31] |> Date.shift(month: 1) |> Date.shift(month: 1)
~D[2016-03-29]

Still, durations are essential for building intervals, recurring events, and modelling scheduling complexities found in the world around us. For DateTimes, Elixir will correctly deal with time zone changes (such as Daylight Saving Time), but provisions are also available in case you want to surface conflicts (for example, you shifted to a wall clock that does not exist, because the clock has been moved forward by one hour). See DateTime.shift/2 for examples.

Finally, a new Kernel.to_timeout/1 function has been added, which helps developers normalize durations and integers to a timeout used by Process APIs. For example, to send a message after one hour, one can now write:

Process.send_after(pid, :wake_up, to_timeout(hour: 1))

v1.17.0 (2024-06-12)

1. Enhancements
Elixir
  • [Access] Add Access.find/1 that mirrors Enum.find/2
  • [Code] Support cursor inside fn/rescue/catch/else/after inside Code.Fragment.container_cursor_to_quoted/2
  • [Date] Add Date.shift/2 to shift dates with duration and calendar-specific semantics
  • [Date] Allow Date to accept years outside of -9999..9999 range
  • [DateTime] Add DateTime.shift/2 to shift datetimes with duration and calendar-specific semantics
  • [Duration] Add a new Duration data type
  • [GenServer] Add c:GenServer.format_status/1 callback
  • [Kernel] Add Kernel.get_in/1 with safe nil-handling for access and structs
  • [Kernel] Add Kernel.is_non_struct_map/1 guard
  • [Kernel] Add Kernel.to_timeout/1
  • [Kernel] Emit warnings for undefined functions from modules defined within the same context as the caller code
  • [Kernel] Support integers in uppercase sigils
  • [Keyword] Add Keyword.intersect/2-3 to mirror the Map API
  • [Macro] Add Macro.Env.define_alias/4, Macro.Env.define_import/4, Macro.Env.define_require/4, Macro.Env.expand_alias/4, Macro.Env.expand_import/5, and Macro.Env.expand_require/6 to aid the implementation of language servers and embedded languages
  • [NaiveDateTime] Add NaiveDateTime.shift/2 to shift naive datetimes with duration and calendar-specific semantics
  • [Process] Add Process.set_label/1
  • [String] Add String.byte_slice/3 to slice a string to a maximum number of bytes while keeping it UTF-8 encoded
  • [System] Support use_stdio: false in System.cmd/3 and System.shell/2
  • [Time] Add Time.shift/2 to shift times with duration and calendar-specific semantics
ExUnit
  • [ExUnit] Propagate the test process itself as a caller in start_supervised
  • [ExUnit] Include max cases in ExUnit reports
IEx
  • [IEx.Helpers] Warns if recompile was called and the current working directory changed
  • [IEx.Helpers] Add c/0 as an alias to continue/0
  • [IEx.Pry] Add IEx.Pry.annotate_quoted/3 to annotate a quoted expression with pry breakpoints
Logger
  • [Logger] Format :gen_statem reports using Elixir data structures
  • [Logger] Include process label in logger events
Mix
  • [mix deps] Add :depth option to Mix.SCM.Git, thus supporting shallow clones of Git dependencies
  • [mix deps] Warn if :optional is used in combination with :in_umbrella
  • [mix deps.get] Do not add optional dependency requirements if its parent dep was skipped
  • [mix deps.tree] Add --umbrella-only to mix deps.tree
  • [mix profile.tprof] Add a new profiler, available on Erlang/OTP 27+, which can measure count, time, and heap usage
  • [mix test] Add mix test --breakpoints that sets up a breakpoint before each test that will run
  • [mix test] Add mix test --repeat-until-failure to rerun tests until a failure occurs
  • [mix test] Add mix test --slowest-modules to print slowest modules based on all of the tests they hold
  • [mix test] Generate cover HTML files in parallel
2. Bug fixes
Elixir
  • [bin/elixir.bat] Improve handling of quotes and exclamation marks in flags
  • [Code] Address a bug where AST nodes for (a -> b) were not wrapped as part of the literal encoder
  • [Kernel] Resolve inconsistencies of how .. and ... are handled at the AST level
  • [Kernel] Fix parsing precedence of ambiguous operators followed by containers
  • [Kernel] Do not expand code in quote bind_quoted: ... twice
  • [Kernel] Respect :line property when :file is given as option to quote
  • [Kernel] Do not crash on Macro.escape/2 when passing a quote triplet without valid meta
  • [Kernel] Avoid double tracing events when capturing a function
  • [Kernel] Fix a bug where captured arguments would conflict when a capture included a macro that also used captures
  • [Module] Return default value in Module.get_attribute/3 for persisted attributes which have not yet been written to
IEx
  • [IEx.Helpers] Update the history size whenever history is pruned
Mix
  • [mix deps] Fix error message for diverged SCM definition in sibling
3. Soft deprecations (no warnings emitted)
Elixir
  • [GenServer] Deprecate c:GenServer.format_status/2 callback to align with Erlang/OTP 25+
Mix
  • [mix profile.cprof] Deprecated in favor of the new mix profile.tprof
  • [mix profile.eprof] Deprecated in favor of the new mix profile.tprof
4. Hard deprecations
Elixir
  • [IO] Passing :all to IO.read/2 and IO.binread/2 is deprecated, pass :eof instead
  • [Kernel] Single-quote charlists are deprecated, use ~c instead
  • [Kernel] Deprecate escaping closing delimiter in uppercase sigils
  • [Range] left..right without explicit steps inside patterns and guards is deprecated, write left..right//step instead
  • [Range] Decreasing ranges, such as 10..1 without an explicit step is deprecated, write 10..1//-1 instead
ExUnit
  • [ExUnit.Case] register_test/4 is deprecated in favor of register_test/6 for performance reasons

v1.16.3

Compare Source

1. Bug fixes
Elixir
  • [bin/elixir] Properly handle the --dbg flag in Elixir's CLI
  • [Code.Formatter] Add brackets around keyword lists when formatting the left-hand side of when
  • [Kernel] Only infer size in pinned variable in binary strings when needed
  • [System] Add a note that arguments are unsafe when invoking .bat/.com scripts on Windows via System.cmd/3
  • [Port] Add a note that arguments are unsafe when invoking .bat/.com scripts on Windows
  • [URI] Ensure :undefined fields are properly converted to nil when invoking Erlang's API
Logger
  • [Logger] Ensure translators are persisted across logger restarts
Mix
  • [mix compile] Ensure compile paths are accessible during compilation

v1.16.2

Compare Source

1. Enhancements
Elixir
  • [Code] Emit :defmodule tracing event on module definition
Mix
  • [Mix] Add Mix.install_project_dir/0
  • [Mix] Add environment variable for reusing Mix.install/2 installation
  • [Mix.SCM] Add Mix.SCM.delete/1
2. Bug fixes
Elixir
  • [Code] Fix charlist formatting issue when a single-quoted charlist escapes a double-quote character
  • [Path] Fix regression on how Path.relative_to/2 dealt with "." as input
IEx
  • [IEx.Helpers] Discard mermaid fenced blocks from ansi docs
ExUnit
  • [ExUnit] Properly compared pinned values when building diffs

v1.16.1

Compare Source

1. Bug fixes
Elixir
  • [Code] Fix Code.quoted_to_algebra/2 for operator with :do key as operand
  • [Kernel.ParallelCompiler] Do not crash parallel compiler when it receives diagnostics from additional code evaluation
  • [Kernel.ParallelCompiler] Always log errors at the end of compilation
  • [String] Fix String.capitalize/1 with a single codepoint
IEx
  • [IEx] Fix autocompletion of function signatures on Erlang/OTP 26
  • [IEx] Do not assume $HOME is set
Mix
  • [mix deps.compile] Handle compilation of rebar3 dependencies when rebar3 is on a path with spaces on Unix
  • [mix test] Properly resolve relative paths when running tests from individual files
  • [mix test] Properly resolve Windows paths when running tests from individual files

v1.16.0

Compare Source

Official announcement: https://elixir-lang.org/blog/2023/12/22/elixir-v1-16-0-released/

1. Enhancements
EEx
  • [EEx] Include relative file information in diagnostics
Elixir
  • [Code] Add :emit_warnings for Code.string_to_quoted/2
  • [Code] Automatically include columns in parsing options
  • [Code] Introduce MismatchedDelimiterError for handling mismatched delimiter exceptions
  • [Code.Fragment] Handle anonymous calls in fragments
  • [Code.Formatter] Trim trailing whitespace on heredocs with \r\n
  • [File] Add :offset option to File.stream!/2
  • [Kernel] Auto infer size of matched variable in bitstrings
  • [Kernel] Preserve column information when translating typespecs
  • [Kernel] Suggest module names based on suffix and casing errors when the module does not exist in UndefinedFunctionError
  • [Kernel.ParallelCompiler] Introduce Kernel.ParallelCompiler.pmap/2 to compile multiple additional entries in parallel
  • [Kernel.SpecialForms] Warn if True/False/Nil are used as aliases and there is no such alias
  • [Macro] Add Macro.compile_apply/4
  • [Module] Add support for @nifs annotation from Erlang/OTP 25
  • [Module] Add support for missing @dialyzer configuration
  • [String] Update to Unicode 15.1.0
  • [String] Add String.replace_invalid/2
  • [Task] Add :limit option to Task.yield_many/2
Logger
  • [Logger] Add Logger.levels/0
Mix
  • [mix] Add MIX_PROFILE to profile a list of comma separated tasks
  • [mix archive.install] Support --sparse option
  • [mix compile.app] Warn if both :applications and :extra_applications are used
  • [mix compile.elixir] Pass original exception down to diagnostic :details when possible
  • [mix compile.elixir] Optimize scenario where there are thousands of files in lib/ and one of them is changed
  • [mix deps.clean] Emit a warning instead of crashing when a dependency cannot be removed
  • [mix escript.install] Support --sparse option
  • [mix release] Include include/ directory in releases
  • [mix test] Allow testing multiple file:line at once, such as mix test test/foo_test.exs:13 test/bar_test.exs:27
2. Bug fixes
Elixir
  • [Code] Keep quotes for atom keys in formatter
  • [Code.Fragment] Fix crash in Code.Fragment.surround_context/2 when matching on ->
  • [IO] Raise when using IO.binwrite/2 on terminated device (mirroring IO.write/2)
  • [Kernel] Do not expand aliases recursively (the alias stored in Macro.Env is already expanded)
  • [Kernel] Ensure dbg module is a compile-time dependency
  • [Kernel] Warn when a private function or macro uses unquote/1 and the function/macro itself is unused
  • [Kernel] Re-enabled compiler optimizations for top level functions in scripts (disabled in v1.14.0 but shouldn't impact most programs)
  • [Kernel] Do not define an alias for nested modules starting with Elixir. in their definition
  • [Kernel.ParallelCompiler] Consider a module has been defined in @after_compile callbacks to avoid deadlocks
  • [Macro] Address exception on Macro.to_string/1 for certain ASTs
  • [Path] Lazily evaluate File.cwd!/0 in Path.expand/1 and Path.absname/1
  • [Path] Ensure Path.relative_to/2 returns a relative path when the given argument does not share a common prefix with cwd
ExUnit
  • [ExUnit] Raise on incorrectly dedented doctests
IEx
  • [IEx.Pry] Fix prying functions with only literals in their body
Mix
  • [mix archive.install] Restore code paths after mix archive.install
  • [mix compile] Ensure files with duplicate modules are recompiled whenever any of the files change
  • [mix compile] Update Mix compiler diagnostics documentation and typespecs to match the Elixir compiler behaviour where both lines and columns start from one (before it inaccurately said that columns started from zero)
  • [mix escript.install] Restore code paths after mix escript.install
3. Soft deprecations (no warnings emitted)
Elixir
  • [File] Deprecate File.stream!(file, options, line_or_bytes) in favor of keeping the options as last argument, as in File.stream!(file, line_or_bytes, options)
  • [Kernel.ParallelCompiler] Deprecate Kernel.ParallelCompiler.async/1 in favor of Kernel.ParallelCompiler.pmap/2
  • [Path] Deprecate Path.safe_relative_to/2 in favor of Path.safe_relative/2
Mix
  • [mix compile] Returning a four-element tuple as a position in Mix.Task.Compiler.Diagnostic
4. Hard deprecations
Elixir
  • [Date] Deprecate inferring a range with negative step, call Date.range/3 with a negative step instead
  • [Enum] Deprecate passing a range with negative step on Enum.slice/2, give first..last//1 instead
  • [Kernel] ~R/.../ is deprecated in favor of ~r/.../. This is because ~R/.../ still allowed escape codes, which did not fit the definition of uppercase sigils
  • [String] Deprecate passing a range with negative step on String.slice/2, give first..last//1 instead
ExUnit
  • [ExUnit.Formatter] Deprecate format_time/2, use format_times/1 instead
Mix
  • [mix compile.leex] Require :leex to be added as a compiler to run the leex compiler
  • [mix compile.yecc] Require :yecc to be added as a compiler to run the yecc compiler

v1.15.8

Compare Source

1. Bug fixes
Elixir
  • [bin/elixir] Properly handle the --dbg flag in Elixir's CLI
  • [System] Add a note that arguments are unsafe when invoking .bat/.com scripts on Windows via System.cmd/3
  • [Port] Add a note that arguments are unsafe when invoking .bat/.com scripts on Windows
  • [URI] Ensure :undefined fields are properly converted to nil when invoking Erlang's API
Logger
  • [Logger] Ensure translators are persisted across logger restarts
Mix
  • [mix compile] Ensure compile paths are accessible during compilation

v1.15.7

Compare Source

1. Enhancements
Elixir
  • [Elixir] Allow code evaluation across Elixir versions
2. Bug fixes
EEx
  • [EEx] Do not emit duplicate warnings from tokenizer
Mix
  • [mix format] Correctly match file to subdirectory in Mix.Tasks.Format.formatter_for_file/2

v1.15.6

Compare Source

This release also includes fixes to the Windows installer.

1. Bug fixes
EEx
  • [EEx] Do not crash when printing tokenizer warnings
Elixir
  • [Code] Fix formatter for nested * in bitstrings
  • [Code] Improve feedback when an invalid block is given Code.quoted_to_algebra/2
  • [Kernel] Trace functions before they are inlined
Mix
  • [mix compile] Ensure :extra_applications declare in umbrella projects are loaded
  • [mix deps.get] Do not check for invalid applications before deps.get
  • [mix deps.update] Do not check for invalid applications before deps.update
  • [mix format] Load plugins when invoking the formatter from an IDE

v1.15.5

Compare Source

1. Enhancements
IEx
  • [IEx.Autocomplete] Speed up loading of struct suggestions
2. Bug fixes
Elixir
  • [Code.Fragment] Fix Code.Fragment.surround_context/2 for aliases and submodules of non-aliases
  • [Kernel] Ensure stacktrace is included when necessary when rescuing multiple exceptions in the same branch
  • [Kernel] Fix index in error message for unused optional arguments
ExUnit
  • [ExUnit.Diff] Fix scenario where diff would not show up due to a timed-out loop
IEx
  • [IEx] Force group leader to run as a binary and unicode in IEx
Mix
  • [mix compile] Do not assume blake is always available
  • [mix format] Load and compile plugins if specified in subdirectories

v1.15.4

Compare Source

1. Bug fixes
Mix
  • [mix archive.build] Disable protocol consolidation when building archiveson archive.install
  • [mix compile] Track removed files per local dependency (this addresses a bug where files depending on modules from path dependencies always recompiled)
  • [mix release] Do not strip relevant chunks from Erlang/OTP 26

v1.15.3

Compare Source

1. Enhancements
Elixir
  • [Kernel] Improve better stacktraces when executing unnested Elixir code in a file
Mix
  • [Mix] Allow to opt out of starting apps in Mix.install/2
2. Bug fixes
Elixir
  • [Code] Ensure with_diagnostics propagate warnings from inner Erlang passes
IEx
  • [IEx] Fix --remsh on Erlang/OTP 25 and earlier
Mix
  • [mix compile.elixir] Ensure __mix_recompile__? callbacks are properly invoked

v1.15.2

Compare Source

1. Bug fixes
IEx
  • [IEx] Fix CLI being unable to boot on Windows

v1.15.1

Compare Source

1. Enhancements
  • [Code] Code.string_to_quoted/2 honors :static_atoms_encoder for multi-letter sigils
2. Bug fixes
ExUnit
  • [ExUnit.CaptureLog] Fix race condition on concurrent capture_log
  • [ExUnit.CaptureLog] Respect options passed to nested capture_log calls
  • [ExUnit.Doctest] Properly compile doctests without results terminated by fences
  • [ExUnit.Doctest] Allow variables defined in doctests to be used in expectation
IEx
  • [IEx] Ensure pry works on Erlang/OTP 25 and earlier while IEx is booting
  • [IEx] Code.Fragment.surround_context considers surround context around spaces and parens
Logger
  • [Logger] Do not assume Logger has been loaded at compile-time
  • [Logger.Formatter] Properly handle :function as metadata
Mix
  • [mix compile] Ensure the current project is available on the code path after its Elixir sources are compiled
  • [mix compile] Guarantee yecc/leex are available when emitting warnings from previous runs
  • [mix compile] Fix bug where an external resource was deleted after its
    mtime was successfully retrieved
  • [mix compile] Track removed modules and exports across local deps
  • [mix deps] Fix an issue where dependencies could not be started in an umbrella projects
  • [mix release] Properly handle optional dependencies when there is a conflict in the application start mode
  • [mix release] Remove --werl from release scripts on Erlang/OTP 26

v1.15.0

Compare Source

Official announcement: https://elixir-lang.org/blog/2023/06/19/elixir-v1-15-0-released/

1. Enhancements
EEx
  • [EEx] Include source code snippets in syntax errors
Elixir
  • [Calendar] Add support for epoch time (%s) to Calendar.strftime/2
  • [Code] Code.format_string!/2 now converts 'charlists' into ~c"charlists" by default
  • [Code] Add :on_undefined_variable to the compiler options to preserve the warning behaviour which was deprecated back in Elixir v1.4
  • [Code] Add Code.loaded?/1 and Code.ensure_all_loaded(!)/1
  • [Code] Add Code.prepend_paths/1, Code.append_paths/1, and Code.delete_paths/1
  • [Code] Add Code.with_diagnostics/2 to return diagnostics when compiling and evaluating code
  • [Code.Fragment] Support nested expressions in Code.Fragment.cursor_context/1
  • [Code.Fragment] Keep operators and no paren calls in Code.Fragment.container_cursor_to_quoted/1
  • [Date] Add Date.before?/2 and Date.after?/2
  • [DateTime] Add DateTime.before?/2 and DateTime.after?/2
  • [DateTime] Support precision in DateTime.utc_now/2
  • [File] Support distributed File.Stream
  • [Inspect] Inspect now renders 'charlists' as ~c"charlists" by default
  • [Kernel] Break down case and cond inside dbg/2
  • [Kernel] Add t:nonempty_binary/0 and t:nonempty_bitstring/0
  • [Kernel] Treat @behaviours as runtime dependencies
  • [Kernel] Do not add runtime dependencies for alias references in patterns and guards
  • [Kernel] Warn for nested calls without parens inside keywords
  • [Kernel] Support for multi-letter uppercase sigils
  • [Kernel] Introduce mechanism to collect several errors in a module. Previously, as soon as there was a compilation error, compilation would fail. Now the compiler became a bit smarter and will report multiple errors whenever possible as multiple error: ... messages, similar to warning: ...
  • [Kernel] Raise instead of warning on undefined variables. Previously, an undefined variable would attempt to invoke a function of the same name, which led to confusing error messages, especially to newcomers. To enable the previous behaviour, invoke Code.compiler_options(on_undefined_variable: :warn) at the top of your mix.exs
  • [Kernel.CLI] Support --sname undefined/--name undefined so a name is automatically generated
  • [Keyword] Add Keyword.split_with/2
  • [Macro] Improve error message when piping into an expression ending in bracket-based access
  • [Macro.Env] Add Macro.Env.lookup_alias_as/2
  • [Map] Add Map.split_with/2
  • [Map] Add Map.intersect/2 and Map.intersect/3
  • [MapSet] Add MapSet.split_with/2
  • [MapSet] Optimize most functions
  • [NaiveDateTime] Add NaiveDateTime.beginning_of_day/1 and NaiveDateTime.end_of_day/1
  • [NaiveDateTime] Add NaiveDateTime.before?/2 and NaiveDateTime.after?/2
  • [NaiveDateTime] Support precision in NaiveDateTime.utc_now/2
  • [Module] Mark functions as generated in "Docs" chunk
  • [Module] Add Module.get_last_attribute/3
  • [OptionParser] Support :return_separator option
  • [Process] Add Process.alias/0,1 and Process.unalias/1
  • [Range] Add Range.split/2
  • [String] Update Unicode to version 15.0.0
  • [String] Add :fast_ascii mode to String.valid?/2
  • [Supervisor] Add support for automatic shutdown in Supervisor
  • [System] Support :lines in System.cmd/3 to capture output line by line
  • [Task] Remove head of line blocking on Task.yield_many/2
  • [Task] Enable selective receive optimizations in Erlang/OTP 26+
  • [Task] Reduce tasks footprint by avoiding unecessary work during spawning
  • [Task.Supervisor] Do not copy args on temporary Task.Supervisor.start_child/2
  • [Time] Add Time.before?/2 and Time.after?/2
  • [URI] Add URI.append_path/2
ExUnit
  • [ExUnit] Add more color configuration to ExUnit CLI formatter
  • [ExUnit.Callbacks] Accept {module, function} tuples in ExUnit setup callbacks
  • [ExUnit.Case] Add ExUnit.Case.get_last_registered_test/1
  • [ExUnit.Doctest] Add ExUnit.DocTest.doctest_file/2
  • [ExUnit.Doctest] Include doctest_data in doctest tags
  • [ExUnit.Formatter] When comparing two anonymous functions, defined at the same place but capturing a different environment, we will now also diff the environments
IEx
  • [IEx] Make pry opt-in on dbg with --dbg pry
  • [IEX] Support IEX_HOME
  • [IEx.Autocomplete] Only provide aliases when autocompleting alias, import, and require
  • [IEx.Autocomplete] Provide field completion on map and struct updates
  • [IEx.Helpers] Add runtime_info(:allocators)
  • [IEx.Info] Implement protocol for Range, DateTime, and Regex
Logger
  • [Logger] Add Logger.add_handlers/1 and Logger.default_formatter/1
  • [Logger] Introduce default_formatter and default_handler configuration for Logger which configures Erlang/OTP logger
  • [Logger] Add :always_evaluate_messages configuration to Logger
  • [Logger.Formatter] Implement the Erlang Logger formatter API
  • [Logger.Formatter] Add support for ports in Logger metadata
Mix
  • [mix app.start] Allow applications to be started concurrently via the :start_concurrently configuration
  • [mix compile] Set --all-warnings by default
  • [mix compile] Reduce the amount of filesystem lookups for path dependencies by storing timestamps in manifests
  • [mix compile] Track digests of @external_resources
  • [mix compile.app] Write optional_applications to .app file
  • [mix compile.elixir] Add --purge-consolidation-path-if-stale which will purge the given consolidation path if compilation is required
  • [mix deps.compile] Automatically recompile dependencies if their compile env changes
  • [mix deps.get] Automatically install Hex and Rebar on mix deps.get/mix deps.update
  • [mix deps.get] Support --check-locked which raises if changes to the lockfile are required
  • [mix eval] Allow passing additional arguments
  • [mix format] Support --no-exit option
  • [mix format] Allow multiple formatters per file extension and sigil
  • [mix format] Show diffs whenever --check-formatted fails
  • [mix format] Allow the formatting root to be configured
  • [mix loadpaths] Cache deps and archive loadpaths in Erlang/OTP 26
  • [mix profile.fprof] Support --trace-to-file to improve performance when working with large outputs
  • [mix release] Allow passing additional arguments to the eval command
  • [mix xref graph] Support --output flag
  • [Mix.Project] Support def cli to unify all CLI defaults in a single place
  • [Mix.Project] Add Mix.Project.deps_tree/1
2. Bug fixes
Elixir
  • [Code.Formatter] Fix a scenario where a keyword followed by parenthesis could go above the maximum line length
  • [Code.Formatter] Remove unnecessary parens in nullary type funs
  • [Exception] Fix operator precedence when printing guards in Exception.blame/3
  • [File] Do not raise if there are file system race conditions in File.cp/2
  • [File] Do not raise when deleting write-only empty directories on File.rm_rf/1
  • [Kernel] Expand macros on the left side of -> in try/rescue
  • [Kernel] Raise on misplaced ... inside typespecs
  • [Kernel] Do not import behaviour_info and module_info functions from Erlang modules
  • [Kernel] Raise when macros are given to dialyzer
  • [Kernel.ParallelCompiler] Make sure compiler doesn't crash when there are stray messages in the inbox
  • [Kernel.ParallelCompiler] Track compile and runtime warnings separately
  • [Module] Ensure that Module.get_attribute/3 returns nil and not the given default value when an attribute has been explicitly set as nil
  • [System] Fix race condition when a script would terminate before System.stop/1 executes
  • [Task] Do not double log Task failure reports
  • [URI] Make sure URI.merge/2 works accordingly with relative paths
ExUnit
  • [ExUnit] Fix crash when @tag capture_log: true was set to true and the Logger application was shut down in the middle of the test
  • [ExUnit] Do not merge context as tags inside the runner to reduce memory usage when emitting events to formatters
  • [ExUnit] Mark test cases as invalid when an exit occurs during setup_all
  • [ExUnit] Do not expand or collect vars from quote in ExUnit assertions
  • [ExUnit.DocTest] Ensure proper line is returned when failing to parse doctest results
  • [ExUnit.Doctest] Fix line information when a doctest with multiple assertions fails
IEx
  • [IEx] Do not spawn a process to read IO. This fixes a bug where multiline paste stopped working
    whenever the input reader was killed
  • [IEx] Do not perform completion for prompts triggered during code evaluation
Mix
  • [mix compile] Include cwd in compiler cache key
  • [mix release] Fix Windows service when invoking erlsrv.exe in path with spaces
  • [mix xref] Raise early if mix xref is used at the umbrella root
3. Soft deprecations (no warnings emitted)
Elixir
  • [File] File.cp/3 and File.cp_r/3 with a function as third argument
    is deprecated in favor of a keyword list
  • [Kernel] Require pin variable when accessing variable inside binary size in match
  • [Kernel.ParallelCompiler] Require the :return_diagnostics option to be
    set to true when compiling or requiring code
Logger
  • [Logger] add_backend/2, remove_backend/2, and configure_backend/2 have been deprecated
    in favor of the new :logger_backends dependency
  • [Logger] The :console configuration has been deprecated in favor of :default_formatter
  • [Logger] The :backends configuration has been deprecated in favor of Logger.add_handlers/1
Mix
  • [Mix.Project] :preferred_cli_env is deprecated in favor of :preferred_envs in def cli
  • [Mix.Project] :preferred_cli_target is deprecated in favor of :preferred_targets in def cli
  • [mix local] The environment variable HEX_MIRROR is deprecated in favor of HEX_BUILDS_URL
4. Hard deprecations
Elixir
  • [Calendar] Calendar.ISO.day_of_week/3 is deprecated in favor of Calendar.ISO.day_of_week/4
  • [Exception] Exception.exception?/1 is deprecated in favor of Kernel.is_exception/1
  • [Kernel] Deprecate ... as a valid function call identifier
  • [Regex] Regex.regex?/1 is deprecated in favor of Kernel.is_struct/2
Logger
  • [Logger] Logger.warn/2 is deprecated in favor of Logger.warning/2

v1.14.5

Compare Source

This release contains fixes for Erlang/OTP 26.

Bug fixes
Elixir
  • [CLI] Fix a bug where stdout would block when there was no attached terminal on Windows when running on Erlang/OTP 26
Mix
  • [Mix] Properly set SSL configuration for Mix downloads when running on Erlang/OTP 26

v1.14.4

Compare Source

This release adds basic support for Erlang/OTP 26. When migrating
to Erlang/OTP 26, keep it mind it changes how maps are stored
internally and they will be printed and traversed in a different
order (note maps never provided a guarantee of their order).
To aid migration, this release adds :sort_maps to inspect
custom options, in case you want to sort them before inspection:

inspect(map, custom_options: [sort_maps: true])
Enhancements
Elixir
  • [Inspect] Add :sort_maps to Inspect.Opts.custom_options
IEx
  • [IEx] Support shell history in Erlang/OTP 26+
Mix
  • [mix compile.elixir] Optimize application tracer
Bug fixes
Elixir
  • [Code] Properly handle blocks with comments in all cases in Code.quoted_to_string_with_comments/2
  • [Kernel] Fix debug_info/4 when returning core_v1
  • [Kernel] Store complete path on quote keep: true to avoid invalid stacktraces
  • [Kernel] Fix column count when tokenizing escaped interpolations
  • [Stream]

Configuration

📅 Schedule: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 Automerge: Enabled.

Rebasing: Whenever PR is behind base branch, or you tick the rebase/retry checkbox.

🔕 Ignore: Close this PR and you won't be reminded about this update again.


  • If you want to rebase/retry this PR, check this box

This PR was generated by Mend Renovate. View the repository job log.

@renovate renovate bot enabled auto-merge (rebase) November 20, 2022 12:08
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from 6a6daab to 61d9532 Compare March 16, 2023 17:37
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.14.2 chore(deps): update dependency elixir to v1.14.3 Mar 16, 2023
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.14.3 chore(deps): update dependency elixir to v1.14.4 Apr 3, 2023
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from 61d9532 to d59938e Compare April 3, 2023 10:18
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from d59938e to e39bf7f Compare May 28, 2023 09:15
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.14.4 chore(deps): update dependency elixir to v1.14.5 May 28, 2023
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from e39bf7f to d08b259 Compare June 19, 2023 13:01
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.14.5 chore(deps): update dependency elixir to v1.15.0 Jun 19, 2023
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from d08b259 to 13e23ff Compare June 30, 2023 17:09
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.15.0 chore(deps): update dependency elixir to v1.15.1 Jun 30, 2023
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from 13e23ff to e52c2d0 Compare July 1, 2023 21:14
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.15.1 chore(deps): update dependency elixir to v1.15.2 Jul 1, 2023
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from e52c2d0 to 8b69ae5 Compare July 15, 2023 10:04
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.15.2 chore(deps): update dependency elixir to v1.15.3 Jul 15, 2023
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from 8b69ae5 to aeda573 Compare July 18, 2023 13:20
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.15.3 chore(deps): update dependency elixir to v1.15.4 Jul 18, 2023
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from aeda573 to f14b298 Compare August 28, 2023 23:26
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.15.4 chore(deps): update dependency elixir to v1.15.5 Aug 28, 2023
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from f14b298 to 4495db9 Compare September 20, 2023 10:14
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.15.5 chore(deps): update dependency elixir to v1.15.6 Sep 20, 2023
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from 4495db9 to 6d1a3a7 Compare October 14, 2023 13:37
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.15.6 chore(deps): update dependency elixir to v1.15.7 Oct 14, 2023
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from 6d1a3a7 to fd9227d Compare December 22, 2023 19:37
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.15.7 chore(deps): update dependency elixir to v1.16.0 Dec 22, 2023
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from fd9227d to 030c6cc Compare January 31, 2024 10:47
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.16.0 chore(deps): update dependency elixir to v1.16.1 Jan 31, 2024
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from 030c6cc to 048da4d Compare March 10, 2024 14:30
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.16.1 chore(deps): update dependency elixir to v1.16.2 Mar 10, 2024
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from 048da4d to fd25d77 Compare May 21, 2024 00:41
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.16.2 chore(deps): update dependency elixir to v1.16.3 May 21, 2024
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from fd25d77 to 5736f8d Compare June 12, 2024 11:23
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.16.3 chore(deps): update dependency elixir to v1.17.0 Jun 12, 2024
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from 5736f8d to b6fdfb3 Compare June 18, 2024 12:25
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.17.0 chore(deps): update dependency elixir to v1.17.1 Jun 18, 2024
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from b6fdfb3 to ede4633 Compare July 7, 2024 00:03
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.17.1 chore(deps): update dependency elixir to v1.17.2 Jul 7, 2024
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from ede4633 to b058fe1 Compare September 18, 2024 17:02
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.17.2 chore(deps): update dependency elixir to v1.17.3 Sep 18, 2024
@renovate renovate bot force-pushed the renovate/elixir-1.x branch from b058fe1 to 25f5191 Compare December 19, 2024 18:29
@renovate renovate bot changed the title chore(deps): update dependency elixir to v1.17.3 chore(deps): update dependency elixir to v1.18.0 Dec 19, 2024
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
Development

Successfully merging this pull request may close these issues.

0 participants