diff options
| author | Loïc Hoguin <[email protected]> | 2025-02-17 10:12:16 +0100 |
|---|---|---|
| committer | Loïc Hoguin <[email protected]> | 2025-02-17 10:12:16 +0100 |
| commit | 7336379ccb91dbad8956b5410a14d5c09fe7755d (patch) | |
| tree | bab98c512835883fd49717b2177309c0ca81d421 | |
| parent | 325106a2c5204b58cc4bc63749e3228274ae7234 (diff) | |
| download | ci.erlang.mk-7336379ccb91dbad8956b5410a14d5c09fe7755d.tar.gz ci.erlang.mk-7336379ccb91dbad8956b5410a14d5c09fe7755d.tar.bz2 ci.erlang.mk-7336379ccb91dbad8956b5410a14d5c09fe7755d.zip | |
OTP-28.0-rc1
| -rw-r--r-- | early-plugins.mk | 100 | ||||
| -rw-r--r-- | release-notes/OTP-28.0-rc1.README.txt | 2440 |
2 files changed, 2498 insertions, 42 deletions
diff --git a/early-plugins.mk b/early-plugins.mk index b2e3a6a..063f531 100644 --- a/early-plugins.mk +++ b/early-plugins.mk @@ -22,43 +22,49 @@ OTP-24 := OTP-24.0.6 OTP-24.1.7 OTP-24.2.2 OTP-24.3.4.17 OTP-25 := OTP-25.0.4 OTP-25.1.2.1 OTP-25.2.3 OTP-25.3.2.17 OTP-26 := OTP-26.0.2 OTP-26.1.2 OTP-26.2.5.8 OTP-27 := OTP-27.0.1 OTP-27.1.3 OTP-27.2.2 - -OTP-18+ := $(OTP-18) $(OTP-19) $(OTP-20) $(OTP-21) $(OTP-22) $(OTP-23) $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) -OTP-19+ := $(OTP-19) $(OTP-20) $(OTP-21) $(OTP-22) $(OTP-23) $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) -OTP-20+ := $(OTP-20) $(OTP-21) $(OTP-22) $(OTP-23) $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) -OTP-21+ := $(OTP-21) $(OTP-22) $(OTP-23) $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) -OTP-22+ := $(OTP-22) $(OTP-23) $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) -OTP-23+ := $(OTP-23) $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) -OTP-24+ := $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) -OTP-25+ := $(OTP-25) $(OTP-26) $(OTP-27) -OTP-26+ := $(OTP-26) $(OTP-27) -OTP-27+ := $(OTP-27) +OTP-28 := OTP-28.0-rc1 + +OTP-18+ := $(OTP-18) $(OTP-19) $(OTP-20) $(OTP-21) $(OTP-22) $(OTP-23) $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) $(OTP-28) +OTP-19+ := $(OTP-19) $(OTP-20) $(OTP-21) $(OTP-22) $(OTP-23) $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) $(OTP-28) +OTP-20+ := $(OTP-20) $(OTP-21) $(OTP-22) $(OTP-23) $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) $(OTP-28) +OTP-21+ := $(OTP-21) $(OTP-22) $(OTP-23) $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) $(OTP-28) +OTP-22+ := $(OTP-22) $(OTP-23) $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) $(OTP-28) +OTP-23+ := $(OTP-23) $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) $(OTP-28) +OTP-24+ := $(OTP-24) $(OTP-25) $(OTP-26) $(OTP-27) $(OTP-28) +OTP-25+ := $(OTP-25) $(OTP-26) $(OTP-27) $(OTP-28) +OTP-26+ := $(OTP-26) $(OTP-27) $(OTP-28) +OTP-27+ := $(OTP-27) $(OTP-28) +OTP-28+ := $(OTP-28) OTP-LATEST-18+ := $(lastword $(OTP-18)) $(lastword $(OTP-19)) \ $(lastword $(OTP-20)) $(lastword $(OTP-21)) $(lastword $(OTP-22)) \ $(lastword $(OTP-23)) $(lastword $(OTP-24)) $(lastword $(OTP-25)) \ - $(lastword $(OTP-26)) $(lastword $(OTP-27)) + $(lastword $(OTP-26)) $(lastword $(OTP-27)) $(lastword $(OTP-28)) OTP-LATEST-19+ := $(lastword $(OTP-19)) $(lastword $(OTP-20)) \ $(lastword $(OTP-21)) $(lastword $(OTP-22)) $(lastword $(OTP-23)) \ $(lastword $(OTP-24)) $(lastword $(OTP-25)) $(lastword $(OTP-26)) \ - $(lastword $(OTP-27)) + $(lastword $(OTP-27)) $(lastword $(OTP-28)) OTP-LATEST-20+ := $(lastword $(OTP-20)) $(lastword $(OTP-21)) \ $(lastword $(OTP-22)) $(lastword $(OTP-23)) $(lastword $(OTP-24)) \ - $(lastword $(OTP-25)) $(lastword $(OTP-26)) $(lastword $(OTP-27)) + $(lastword $(OTP-25)) $(lastword $(OTP-26)) $(lastword $(OTP-27)) \ + $(lastword $(OTP-28)) OTP-LATEST-21+ := $(lastword $(OTP-21)) $(lastword $(OTP-22)) \ $(lastword $(OTP-23)) $(lastword $(OTP-24)) $(lastword $(OTP-25)) \ - $(lastword $(OTP-26)) $(lastword $(OTP-27)) + $(lastword $(OTP-26)) $(lastword $(OTP-27)) $(lastword $(OTP-28)) OTP-LATEST-22+ := $(lastword $(OTP-22)) $(lastword $(OTP-23)) \ $(lastword $(OTP-24)) $(lastword $(OTP-25)) $(lastword $(OTP-26)) \ - $(lastword $(OTP-27)) + $(lastword $(OTP-27)) $(lastword $(OTP-28)) OTP-LATEST-23+ := $(lastword $(OTP-23)) $(lastword $(OTP-24)) \ - $(lastword $(OTP-25)) $(lastword $(OTP-26)) $(lastword $(OTP-27)) + $(lastword $(OTP-25)) $(lastword $(OTP-26)) $(lastword $(OTP-27)) \ + $(lastword $(OTP-28)) OTP-LATEST-24+ := $(lastword $(OTP-24)) $(lastword $(OTP-25)) \ - $(lastword $(OTP-26)) $(lastword $(OTP-27)) + $(lastword $(OTP-26)) $(lastword $(OTP-27)) $(lastword $(OTP-28)) OTP-LATEST-25+ := $(lastword $(OTP-25)) $(lastword $(OTP-26)) \ - $(lastword $(OTP-27)) -OTP-LATEST-26+ := $(lastword $(OTP-26)) $(lastword $(OTP-27)) -OTP-LATEST-27+ := $(lastword $(OTP-27)) + $(lastword $(OTP-27)) $(lastword $(OTP-28)) +OTP-LATEST-26+ := $(lastword $(OTP-26)) $(lastword $(OTP-27)) \ + $(lastword $(OTP-28)) +OTP-LATEST-27+ := $(lastword $(OTP-27)) $(lastword $(OTP-28)) +OTP-LATEST-28+ := $(lastword $(OTP-28)) # We exclude release candidates here because they are not # the latest release, they are the *next* one. @@ -122,9 +128,11 @@ OTP-26-DROPPED := OTP-26.0-rc3 \ OTP-26.0 OTP-26.0.1 OTP-26.1 OTP-26.1.1 OTP-26.2 OTP-26.2.1 OTP-26.2.2 OTP-26.2.3 OTP-26.2.4 OTP-26.2.5 OTP-26.2.5.1 OTP-26.2.5.2 OTP-26.2.5.3 OTP-26.2.5.4 OTP-26.2.5.5 OTP-26.2.5.6 OTP-26.2.5.7 OTP-27-DROPPED := OTP-27.0-rc1 OTP-27.0-rc2 \ OTP-27.1.2 OTP-27.2 OTP-27.2.1 +OTP-28-DROPPED := OTP-DROPPED := $(OTP-18-DROPPED) $(OTP-19-DROPPED) $(OTP-20-DROPPED) \ - $(OTP-21-DROPPED) $(OTP-22-DROPPED) $(OTP-23-DROPPED) $(OTP-24-DROPPED) + $(OTP-21-DROPPED) $(OTP-22-DROPPED) $(OTP-23-DROPPED) $(OTP-24-DROPPED) \ + $(OTP-25-DROPPED) $(OTP-26-DROPPED) $(OTP-27-DROPPED) $(OTP-28-DROPPED) # Configure Erlang.mk's CI plugin. @@ -203,50 +211,58 @@ WINDOWS-OTP-24 := 24.0 24.1 24.2 24.3 WINDOWS-OTP-25 := 25.0 25.1 25.2 25.3 WINDOWS-OTP-26 := 26.0 26.1 26.2 WINDOWS-OTP-27 := 27.0 27.1 27.2 +WINDOWS-OTP-28 := WINDOWS-OTP-18+ := $(WINDOWS-OTP-18) $(WINDOWS-OTP-19) $(WINDOWS-OTP-20) $(WINDOWS-OTP-21) \ $(WINDOWS-OTP-22) $(WINDOWS-OTP-23) $(WINDOWS-OTP-24) $(WINDOWS-OTP-25) $(WINDOWS-OTP-26) \ - $(WINDOWS-OTP-27) + $(WINDOWS-OTP-27) $(WINDOWS-OTP-28) WINDOWS-OTP-19+ := $(WINDOWS-OTP-19) $(WINDOWS-OTP-20) $(WINDOWS-OTP-21) $(WINDOWS-OTP-22) \ - $(WINDOWS-OTP-23) $(WINDOWS-OTP-24) $(WINDOWS-OTP-25) $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) + $(WINDOWS-OTP-23) $(WINDOWS-OTP-24) $(WINDOWS-OTP-25) $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) \ + $(WINDOWS-OTP-28) WINDOWS-OTP-20+ := $(WINDOWS-OTP-20) $(WINDOWS-OTP-21) $(WINDOWS-OTP-22) $(WINDOWS-OTP-23) \ - $(WINDOWS-OTP-24) $(WINDOWS-OTP-25) $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) + $(WINDOWS-OTP-24) $(WINDOWS-OTP-25) $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) $(WINDOWS-OTP-28) WINDOWS-OTP-21+ := $(WINDOWS-OTP-21) $(WINDOWS-OTP-22) $(WINDOWS-OTP-23) $(WINDOWS-OTP-24) \ - $(WINDOWS-OTP-25) $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) + $(WINDOWS-OTP-25) $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) $(WINDOWS-OTP-28) WINDOWS-OTP-22+ := $(WINDOWS-OTP-22) $(WINDOWS-OTP-23) $(WINDOWS-OTP-24) $(WINDOWS-OTP-25) \ - $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) + $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) $(WINDOWS-OTP-28) WINDOWS-OTP-23+ := $(WINDOWS-OTP-23) $(WINDOWS-OTP-24) $(WINDOWS-OTP-25) $(WINDOWS-OTP-26) \ - $(WINDOWS-OTP-27) -WINDOWS-OTP-24+ := $(WINDOWS-OTP-24) $(WINDOWS-OTP-25) $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) -WINDOWS-OTP-25+ := $(WINDOWS-OTP-25) $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) -WINDOWS-OTP-26+ := $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) -WINDOWS-OTP-27+ := $(WINDOWS-OTP-27) + $(WINDOWS-OTP-27) $(WINDOWS-OTP-28) +WINDOWS-OTP-24+ := $(WINDOWS-OTP-24) $(WINDOWS-OTP-25) $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) \ + $(WINDOWS-OTP-28) +WINDOWS-OTP-25+ := $(WINDOWS-OTP-25) $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) $(WINDOWS-OTP-28) +WINDOWS-OTP-26+ := $(WINDOWS-OTP-26) $(WINDOWS-OTP-27) $(WINDOWS-OTP-28) +WINDOWS-OTP-27+ := $(WINDOWS-OTP-27) $(WINDOWS-OTP-28) +WINDOWS-OTP-28+ := $(WINDOWS-OTP-28) WINDOWS-OTP-LATEST-18+ := $(lastword $(WINDOWS-OTP-18)) $(lastword $(WINDOWS-OTP-19)) \ $(lastword $(WINDOWS-OTP-20)) $(lastword $(WINDOWS-OTP-21)) $(lastword $(WINDOWS-OTP-22)) \ $(lastword $(WINDOWS-OTP-23)) $(lastword $(WINDOWS-OTP-24)) $(lastword $(WINDOWS-OTP-25)) \ - $(lastword $(WINDOWS-OTP-26)) $(lastword $(WINDOWS-OTP-27)) + $(lastword $(WINDOWS-OTP-26)) $(lastword $(WINDOWS-OTP-27)) $(lastword $(WINDOWS-OTP-28)) WINDOWS-OTP-LATEST-19+ := $(lastword $(WINDOWS-OTP-19)) $(lastword $(WINDOWS-OTP-20)) \ $(lastword $(WINDOWS-OTP-21)) $(lastword $(WINDOWS-OTP-22)) $(lastword $(WINDOWS-OTP-23)) \ $(lastword $(WINDOWS-OTP-24)) $(lastword $(WINDOWS-OTP-25)) $(lastword $(WINDOWS-OTP-26)) \ - $(lastword $(WINDOWS-OTP-27)) + $(lastword $(WINDOWS-OTP-27)) $(lastword $(WINDOWS-OTP-28)) WINDOWS-OTP-LATEST-20+ := $(lastword $(WINDOWS-OTP-20)) $(lastword $(WINDOWS-OTP-21)) \ $(lastword $(WINDOWS-OTP-22)) $(lastword $(WINDOWS-OTP-23)) $(lastword $(WINDOWS-OTP-24)) \ - $(lastword $(WINDOWS-OTP-25)) $(lastword $(WINDOWS-OTP-26)) $(lastword $(WINDOWS-OTP-27)) + $(lastword $(WINDOWS-OTP-25)) $(lastword $(WINDOWS-OTP-26)) $(lastword $(WINDOWS-OTP-27)) \ + $(lastword $(WINDOWS-OTP-28)) WINDOWS-OTP-LATEST-21+ := $(lastword $(WINDOWS-OTP-21)) $(lastword $(WINDOWS-OTP-22)) \ $(lastword $(WINDOWS-OTP-23)) $(lastword $(WINDOWS-OTP-24)) $(lastword $(WINDOWS-OTP-25)) \ - $(lastword $(WINDOWS-OTP-26)) $(lastword $(WINDOWS-OTP-27)) + $(lastword $(WINDOWS-OTP-26)) $(lastword $(WINDOWS-OTP-27)) $(lastword $(WINDOWS-OTP-28)) WINDOWS-OTP-LATEST-22+ := $(lastword $(WINDOWS-OTP-22)) $(lastword $(WINDOWS-OTP-23)) \ $(lastword $(WINDOWS-OTP-24)) $(lastword $(WINDOWS-OTP-25)) $(lastword $(WINDOWS-OTP-26)) \ - $(lastword $(WINDOWS-OTP-27)) + $(lastword $(WINDOWS-OTP-27)) $(lastword $(WINDOWS-OTP-28)) WINDOWS-OTP-LATEST-23+ := $(lastword $(WINDOWS-OTP-23)) $(lastword $(WINDOWS-OTP-24)) \ - $(lastword $(WINDOWS-OTP-25)) $(lastword $(WINDOWS-OTP-26)) $(lastword $(WINDOWS-OTP-27)) + $(lastword $(WINDOWS-OTP-25)) $(lastword $(WINDOWS-OTP-26)) $(lastword $(WINDOWS-OTP-27)) \ + $(lastword $(WINDOWS-OTP-28)) WINDOWS-OTP-LATEST-24+ := $(lastword $(WINDOWS-OTP-24)) $(lastword $(WINDOWS-OTP-25)) \ - $(lastword $(WINDOWS-OTP-26)) $(lastword $(WINDOWS-OTP-27)) + $(lastword $(WINDOWS-OTP-26)) $(lastword $(WINDOWS-OTP-27)) $(lastword $(WINDOWS-OTP-28)) WINDOWS-OTP-LATEST-25+ := $(lastword $(WINDOWS-OTP-25)) $(lastword $(WINDOWS-OTP-26)) \ - $(lastword $(WINDOWS-OTP-27)) -WINDOWS-OTP-LATEST-26+ := $(lastword $(WINDOWS-OTP-26)) $(lastword $(WINDOWS-OTP-27)) -WINDOWS-OTP-LATEST-27+ := $(lastword $(WINDOWS-OTP-27)) + $(lastword $(WINDOWS-OTP-27)) $(lastword $(WINDOWS-OTP-28)) +WINDOWS-OTP-LATEST-26+ := $(lastword $(WINDOWS-OTP-26)) $(lastword $(WINDOWS-OTP-27)) \ + $(lastword $(WINDOWS-OTP-28)) +WINDOWS-OTP-LATEST-27+ := $(lastword $(WINDOWS-OTP-27)) $(lastword $(WINDOWS-OTP-28)) +WINDOWS-OTP-LATEST-28+ := $(lastword $(WINDOWS-OTP-28)) # @todo Add support for release candidates (we don't want them as the "latest"). WINDOWS-OTP-LATEST := $(lastword $(WINDOWS-OTP-18+)) diff --git a/release-notes/OTP-28.0-rc1.README.txt b/release-notes/OTP-28.0-rc1.README.txt new file mode 100644 index 0000000..9202369 --- /dev/null +++ b/release-notes/OTP-28.0-rc1.README.txt @@ -0,0 +1,2440 @@ +Inital Release: OTP 28.0 +Git Tag: OTP-28.0 +Date: 2025-02-12 +Trouble Report Id: OTP-16607, OTP-19096, OTP-19115, OTP-19125, + OTP-19127, OTP-19135, OTP-19141, OTP-19144, + OTP-19155, OTP-19156, OTP-19159, OTP-19161, + OTP-19180, OTP-19184, OTP-19194, OTP-19204, + OTP-19207, OTP-19224, OTP-19226, OTP-19228, + OTP-19230, OTP-19231, OTP-19233, OTP-19250, + OTP-19259, OTP-19262, OTP-19263, OTP-19271, + OTP-19278, OTP-19279, OTP-19285, OTP-19287, + OTP-19290, OTP-19295, OTP-19296, OTP-19297, + OTP-19303, OTP-19306, OTP-19308, OTP-19313, + OTP-19314, OTP-19315, OTP-19317, OTP-19323, + OTP-19324, OTP-19334, OTP-19337, OTP-19339, + OTP-19343, OTP-19345, OTP-19354, OTP-19355, + OTP-19364, OTP-19367, OTP-19369, OTP-19371, + OTP-19376, OTP-19386, OTP-19393, OTP-19394, + OTP-19396, OTP-19398, OTP-19401, OTP-19403, + OTP-19404, OTP-19406, OTP-19413, OTP-19414, + OTP-19419, OTP-19420, OTP-19421, OTP-19422, + OTP-19425, OTP-19426, OTP-19427, OTP-19430, + OTP-19431, OTP-19432, OTP-19441, OTP-19450, + OTP-19451, OTP-19452, OTP-19453, OTP-19454, + OTP-19456, OTP-19460, OTP-19463, OTP-19465, + OTP-19472, OTP-19473, OTP-19474, OTP-19476, + OTP-19477, OTP-19478, OTP-19479, OTP-19480, + OTP-19481, OTP-19484, OTP-19485 +Seq num: #9388, GH-7819, GH-8037, GH-8099, GH-8113, + GH-8223, GH-8483, GH-8558, GH-8822, GH-8842, + GH-8967, GH-8985, GH-9092, GH-9113, GH-9173, + GH-9255, GH-9279, OTP-16608, PR-7830, + PR-8078, PR-8100, PR-8207, PR-8261, PR-8429, + PR-8494, PR-8540, PR-8547, PR-8556, PR-8573, + PR-8589, PR-8590, PR-8592, PR-8600, PR-8625, + PR-8642, PR-8651, PR-8660, PR-8697, PR-8699, + PR-8704, PR-8734, PR-8772, PR-8792, PR-8793, + PR-8798, PR-8805, PR-8812, PR-8820, PR-8862, + PR-8885, PR-8887, PR-8894, PR-8913, PR-8926, + PR-8932, PR-8937, PR-8938, PR-8943, PR-8945, + PR-8960, PR-8962, PR-8966, PR-8968, PR-8973, + PR-8975, PR-8976, PR-8988, PR-9005, PR-9006, + PR-9013, PR-9019, PR-9020, PR-9042, PR-9045, + PR-9079, PR-9082, PR-9083, PR-9094, PR-9095, + PR-9106, PR-9116, PR-9121, PR-9122, PR-9129, + PR-9154, PR-9171, PR-9186, PR-9192, PR-9207, + PR-9219, PR-9229, PR-9231, PR-9232, PR-9246, + PR-9251, PR-9253, PR-9271, PR-9272, PR-9275, + PR-9276, PR-9277, PR-9280, PR-9289, PR-9299, + PR-9305, PR-9316, PR-9330, PR-9333, PR-9342, + PR-9344, PR-9363, PR-9376, PR-9396, PR-9398, + PR-9399, PR-9402 +System: OTP +Release: 28 +Application: asn1-5.3.2, common_test-1.28, compiler-9.0, + crypto-5.6, debugger-6.0, dialyzer-5.4, + diameter-2.5, edoc-1.4, eldap-1.2.15, + erl_interface-5.6, erts-16.0, eunit-2.10, + inets-9.3.2, jinterface-1.15, kernel-10.3, + megaco-4.8, mnesia-4.24, odbc-2.16, + os_mon-2.11, parsetools-2.7, + runtime_tools-2.2, sasl-4.3, snmp-5.19, + ssh-5.3, ssl-11.3, stdlib-7.0, + syntax_tools-4.0, tools-4.1.2, wx-2.5 +Predecessor: OTP + +Check out the git tag OTP-28.0, and build a full OTP system including +documentation. + +# HIGHLIGHTS + +- For various error types, the compiler now tries to suggest potential fixes by + adding "did you mean ...?" at the end of error messages. + + When a function is used with wrong arity, the compiler will try to suggest a + defined function with the same name but a different arity. For example, given + the following module: + + -module(typos). + -export([t/0]). + bar(A) -> A. + bar(A,A,A) -> A. + bar(A,A,A,A) -> A. + t() -> bar(0, 0). + + The compiler will emit the following message: + + typo.erl:6:12: function bar/2 undefined, did you mean bar/1,3,4? + % 6| t() -> bar(0, 0). + % | ^ + + For compiler errors that can easily be caused by typos, the compiler will try + to suggest what the correct variable or function name, could be. For example, + given the following module: + + -module(typos). + -export([bar/2]). + + bar(A0, B0) -> + A + B. + + the compiler will emit the following error messages: + + typos.erl:5:5: variable 'A' is unbound, did you mean 'A0'? + % 5| A + B. + % | ^ + + typos.erl:5:9: variable 'B' is unbound, did you mean 'B0'? + % 5| A + B. + % | ^ + + Error types that now suggest correct arities: `bad_inline`, `undefined_nif`, + `bad_nowarn_unused_function`, `bad_nowarn_bif_clash`, `undefined_function`. + + Error types that now suggest correct names: `bad_inline`, `undefined_nif`, + `bad_nowarn_unused_function`, `undefined_on_load`, `undefined_function`, + `undefined_record`, `undefined_field`, `unbound_var`. + + Using a function with wrong arity has higher precedence than having a typo in + the function name. If the compiler can find a defined function with the same + name but a different arity, it will not suggest a defined function with a + close-enough name, regardless of arity. + + Own Id: OTP-19180 + Application(s): compiler, stdlib + Related Id(s): PR-8699, PR-9094 + +- Comprehensions have been extended with zip generators according to EEP 73. + + Example: + + 1> [A+B || A <- [1,2,3] && B <- [4,5,6]]. + [5,7,9] + + Own Id: OTP-19184 + Application(s): compiler, debugger, stdlib, syntax_tools + Related Id(s): PR-8926 + +- The `erl -noshell` mode has been updated to have two sub modes called `raw` + and `cooked`, where `cooked` is the old default behaviour and `raw` can be + used to bypass the line-editing support of the native terminal. Using `raw` + mode it is possible to read keystrokes as they happen without the user having + to press Enter. Also, the `raw` mode does not echo the typed characters to + stdout. An example of how to create a tic-tac-toe game using this mechanism is + included in the documentation. + + Own Id: OTP-19314 + Application(s): erts, stdlib + Related Id(s): GH-8037, PR-8962 + +- New strict generators have been added for comprehensions. + + The currently existing generators are "relaxed": they ignore terms in the + right-hand side expression that do not match the left-hand side pattern. + + The new strict generators fail with exception `badmatch` if a pattern doesn't + match. + + Examples: + + Using the current relaxed generator operator `<-`, any element not matching + the pattern `{_,_}` will be silently discarded: + + 1> [T || {_,_}=T <- [{ok,1},ok,{error,2}]]. + [{ok,1},{error,2}] + + If the intention is that all lists processed by a list comprehension must only + contain tuples of size two, using the new strict version of the operator + ensures that term not matching will cause a crash: + + 2> [T || {_,_}=T <:- [{ok,1},ok,{error,2}]]. + ** exception error: no match of right hand side value ok + + Using the strict generator operator to mark the intention that all list + elements must match the pattern could help finding mistakes quicker if + something unpexected is added to the list processed by the generator. + + The strict version for bitstring generators is `<:=`. + + Own Id: OTP-19317 + Application(s): compiler, debugger, stdlib, syntax_tools + Related Id(s): PR-8625 + +- The `join(Binaries, Separator)` function that joins a list of binaries has + been added to the `binary` module. + + Own Id: OTP-19337 + Application(s): stdlib + Related Id(s): GH-8099, PR-8100 + +- EEP-69: Nominal Types has been implemented. As a side effect, nominal types + can encode opaque types. We changed all opaque-handling logic and improved + opaque warnings in Dialyzer. + + All existing Erlang type systems are structural: two types are seen as + equivalent if their structures are the same. Type comparisons are based on the + structures of the types, not on how the user explicitly defines them. For + example, in the following example, `meter()` and `foot()` are equivalent. The + two types can be used interchangeably. Neither of them differ from the basic + type `integer()`. + + -type meter() :: integer(). + -type foot() :: integer(). + + Nominal typing is an alternative type system, where two types are equivalent + if and only if they are declared with the same type name. The EEP proposes one + new syntax -nominal for declaring nominal types. Under nominal typing, + `meter()` and `foot()` are no longer compatible. Whenever a function expects + type `meter()`, passing in type `foot()` would result in a Dialyzer error. + + -nominal meter() :: integer(). + -nominal foot() :: integer(). + + More nominal type-checking rules can be found in the EEP. It is worth noting + that most work for adding nominal types and type-checking is in + `erl_types.erl`. The rest are changes that removed the previous opaque + type-checking, and added an improved version of it using nominal type-checking + with reworked warnings. + + Backwards compatibility for opaque type-checking is not preserved by this PR. + Previous opaque warnings can appear with slightly different wordings. A new + kind of opaque warning `opaque_union` is added, together with a Dialyzer + option `no_opaque_union` to turn this kind of warnings off. + + Own Id: OTP-19364 + Application(s): dialyzer, diameter, edoc, erts, eunit, kernel, mnesia, + parsetools, runtime_tools, snmp + Related Id(s): PR-9079 + +- Module `re` has been updated to use PCRE2, which is mostly backward + compatible with PCRE. + + The most noticeable incompatibilities are + + - The default character encoding is pure ASCII and not Latin1. Unicode support + is still available with options `unicode` and `ucp`. + - Options `bsr_anycrlf`, `bsr_unicode` and `{newline,_}` are only set when a + regex is compiled and cannot be changed at matching for precompiled regex. + + Own Id: OTP-19431 + Application(s): erts, stdlib + Related Id(s): PR-9299 + + *** POTENTIAL INCOMPATIBILITY *** + +- It is now possible to use any base for floating point numbers as described in + EEP 75: Based Floating Point Literals. + + Computers represent floating point numbers in binary, but such numbers are + typically printed using base ten, for example 0.314159265e1. To maintain exact + bit-level precision when converting numbers to and from text, it is better to + use a base that matches the internally used base, such as 16 for a compact but + still exact representation, or 2 for visualizing or writing down the exact + internal format. One particular case where such exact representations are + useful is in code generating tools. + + Examples: + + > 2#0.111. + 0.875 + > 16#fefe.fefe#e16. + 1.2041849337671418e24 + + Own Id: OTP-19452 + Application(s): otp, stdlib + Related Id(s): PR-9106 + +- There is a new `zstd` module that does Zstandard compression. + + Own Id: OTP-19477 + Application(s): stdlib + Related Id(s): PR-9316 + +# POTENTIAL INCOMPATIBILITIES + +- `proc_lib:stop/1,3` (and in extension gen_server:stop/3, gen_statem:stop/3 + and so on) have been updated to not throw an error if the process to be + stopped exits with the same reason as given to proc_lib:stop/3. + + Own Id: OTP-19233 + Application(s): stdlib + Related Id(s): PR-8772 + +- The size of an atom in the Erlang source code was limited to 255 bytes in + previous releases, meaning that an atom containing only emojis could contain + only 63 emojis. + + While atoms are still only allowed to contain 255 characters, the number of + bytes is no longer limited. + + External tools that parse the `AtU8` chunk of a BEAM file directly need to be + updated. Tools that use + `beam_lib:chunks(Beam, [atoms)`](beam_lib:chunks/2) to read the atom table + will continue to work. + + Own Id: OTP-19285 + Application(s): compiler, erts, stdlib + Related Id(s): PR-8913 + +- The `undec_rest` option would be ignored in generated functions for exclusive + decode. The option is now respected, meaning that the return value from such + functions are now three-tuples instead of a two-tuples. + + Own Id: OTP-19290 + Application(s): asn1 + Related Id(s): PR-8798 + +- The literals chunk in BEAM is no longer compressed, resulting in slightly + smaller BEAM files when a BEAM file is stripped using + beam_lib:strip_files/1. + + This is a potential incompatibility for tools that read and interpret the + contents of the literal chunk. One way to update such tools to work with the + new format is to retrieve the chunk using + `beam_lib:chunks(Beam, [literals)`](beam_lib:chunks/2). + + Own Id: OTP-19323 + Application(s): compiler, erts, stdlib + Related Id(s): GH-8967, PR-8988 + +- The `abort_if_missing_suites` option now defaults to `true`. If you prefer the + old behavior, set `abort_if_missing_suites` to `false` in your test runs. + + Own Id: OTP-19355 + Application(s): common_test + Related Id(s): PR-9045 + +- CBC algorithms are not offered by default. See Configuring algorithms in SSH + if you wish to enable them. + + Own Id: OTP-19420 + Application(s): ssh + Related Id(s): PR-9277 + +- Module `re` has been updated to use PCRE2, which is mostly backward + compatible with PCRE. + + The most noticeable incompatibilities are + + - The default character encoding is pure ASCII and not Latin1. Unicode support + is still available with options `unicode` and `ucp`. + - Options `bsr_anycrlf`, `bsr_unicode` and `{newline,_}` are only set when a + regex is compiled and cannot be changed at matching for precompiled regex. + + Own Id: OTP-19431 + Application(s): erts, stdlib + Related Id(s): PR-9299 + + *** HIGHLIGHT *** + +# OTP-28.0 + +## Improvements and New Features + +- It is now possible to use any base for floating point numbers as described in + EEP 75: Based Floating Point Literals. + + Computers represent floating point numbers in binary, but such numbers are + typically printed using base ten, for example 0.314159265e1. To maintain exact + bit-level precision when converting numbers to and from text, it is better to + use a base that matches the internally used base, such as 16 for a compact but + still exact representation, or 2 for visualizing or writing down the exact + internal format. One particular case where such exact representations are + useful is in code generating tools. + + Examples: + + > 2#0.111. + 0.875 + > 16#fefe.fefe#e16. + 1.2041849337671418e24 + + Own Id: OTP-19452 + Related Id(s): PR-9106 + + *** HIGHLIGHT *** + +- Fixed licenses in files and added ORT curations to the following apps: otp, + eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and ERTS. + + Own Id: OTP-19478 + Related Id(s): PR-9376, PR-9402 + +# asn1-5.3.2 + +## Fixed Bugs and Malfunctions + +- The `undec_rest` option would be ignored in generated functions for exclusive + decode. The option is now respected, meaning that the return value from such + functions are now three-tuples instead of a two-tuples. + + Own Id: OTP-19290 + Related Id(s): PR-8798 + + *** POTENTIAL INCOMPATIBILITY *** + +> #### Full runtime dependencies of asn1-5.3.2 +> +> erts-14.0, kernel-9.0, stdlib-5.0 + +# common_test-1.28 + +## Fixed Bugs and Malfunctions + +- Replaced calls to deprecated `crypto:start()` with + `application:start(crypto)`. + + Own Id: OTP-19485 + Related Id(s): PR-8592 + +## Improvements and New Features + +- The overage reports in HTML can be rendered in dark mode if requested by the + user's browser. + + Own Id: OTP-19159 + Related Id(s): PR-7830 + +- The `abort_if_missing_suites` option now defaults to `true`. If you prefer the + old behavior, set `abort_if_missing_suites` to `false` in your test runs. + + Own Id: OTP-19355 + Related Id(s): PR-9045 + + *** POTENTIAL INCOMPATIBILITY *** + +- Added support for compiling Erlang/OTP for Windows on ARM64. + + Own Id: OTP-19480 + Related Id(s): PR-8734 + +> #### Full runtime dependencies of common_test-1.28 +> +> compiler-6.0, crypto-4.5, debugger-4.1, erts-7.0, ftp-1.0, inets-6.0, +> kernel-8.4, observer-2.1, runtime_tools-1.8.16, sasl-2.5, snmp-5.1.2, ssh-4.0, +> stdlib-4.0, syntax_tools-1.7, tools-3.2, xmerl-1.3.8 + +# compiler-9.0 + +## Fixed Bugs and Malfunctions + +- The compiler will now emit warnings when some map patterns cannot possibly + match because a previous clauses matches the same pattern. For example: + + mm_1(#{}) -> a; + mm_1(#{b := B}) -> {b,B}. + + mm_2(#{a := A}) -> {a,A}; + mm_2(#{a := A, b := B}) -> {b,A,B}. + + The second clause of these function can never match and the compiler will now + emit a warning for both of them. + + Note that the compiler is not guaranteed to emit warnings for every possible + map pattern that cannot match. + + Own Id: OTP-19141 + Related Id(s): GH-8558, PR-8600 + +- The size of an atom in the Erlang source code was limited to 255 bytes in + previous releases, meaning that an atom containing only emojis could contain + only 63 emojis. + + While atoms are still only allowed to contain 255 characters, the number of + bytes is no longer limited. + + External tools that parse the `AtU8` chunk of a BEAM file directly need to be + updated. Tools that use + `beam_lib:chunks(Beam, [atoms)`](beam_lib:chunks/2) to read the atom table + will continue to work. + + Own Id: OTP-19285 + Related Id(s): PR-8913 + + *** POTENTIAL INCOMPATIBILITY *** + +- The literals chunk in BEAM is no longer compressed, resulting in slightly + smaller BEAM files when a BEAM file is stripped using + beam_lib:strip_files/1. + + This is a potential incompatibility for tools that read and interpret the + contents of the literal chunk. One way to update such tools to work with the + new format is to retrieve the chunk using + `beam_lib:chunks(Beam, [literals)`](beam_lib:chunks/2). + + Own Id: OTP-19323 + Related Id(s): GH-8967, PR-8988 + + *** POTENTIAL INCOMPATIBILITY *** + +- The final validation step in the compiler will now reject modules containing + functions with more than 255 arguments. No impact is expected as the emulator + has always refused to load these modules. + + Own Id: OTP-19376 + Related Id(s): GH-9113, PR-9121 + +- Replaced calls to deprecated `crypto:start()` with + `application:start(crypto)`. + + Own Id: OTP-19485 + Related Id(s): PR-8592 + +## Improvements and New Features + +- The EEP-48 doc chunk embedded into `.beam` files by the compiler is now + `compressed` and `deterministic`. + + Own Id: OTP-19096 + Related Id(s): PR-8494 + +- Provided that the map argument for a maps:put/3 call is known to the + compiler to be a map, the compiler will replace such calls with the + corresponding update using the map syntax. + + Own Id: OTP-19115 + Related Id(s): PR-8540 + +- For various error types, the compiler now tries to suggest potential fixes by + adding "did you mean ...?" at the end of error messages. + + When a function is used with wrong arity, the compiler will try to suggest a + defined function with the same name but a different arity. For example, given + the following module: + + -module(typos). + -export([t/0]). + bar(A) -> A. + bar(A,A,A) -> A. + bar(A,A,A,A) -> A. + t() -> bar(0, 0). + + The compiler will emit the following message: + + typo.erl:6:12: function bar/2 undefined, did you mean bar/1,3,4? + % 6| t() -> bar(0, 0). + % | ^ + + For compiler errors that can easily be caused by typos, the compiler will try + to suggest what the correct variable or function name, could be. For example, + given the following module: + + -module(typos). + -export([bar/2]). + + bar(A0, B0) -> + A + B. + + the compiler will emit the following error messages: + + typos.erl:5:5: variable 'A' is unbound, did you mean 'A0'? + % 5| A + B. + % | ^ + + typos.erl:5:9: variable 'B' is unbound, did you mean 'B0'? + % 5| A + B. + % | ^ + + Error types that now suggest correct arities: `bad_inline`, `undefined_nif`, + `bad_nowarn_unused_function`, `bad_nowarn_bif_clash`, `undefined_function`. + + Error types that now suggest correct names: `bad_inline`, `undefined_nif`, + `bad_nowarn_unused_function`, `undefined_on_load`, `undefined_function`, + `undefined_record`, `undefined_field`, `unbound_var`. + + Using a function with wrong arity has higher precedence than having a typo in + the function name. If the compiler can find a defined function with the same + name but a different arity, it will not suggest a defined function with a + close-enough name, regardless of arity. + + Own Id: OTP-19180 + Related Id(s): PR-8699, PR-9094 + + *** HIGHLIGHT *** + +- Comprehensions have been extended with zip generators according to EEP 73. + + Example: + + 1> [A+B || A <- [1,2,3] && B <- [4,5,6]]. + [5,7,9] + + Own Id: OTP-19184 + Related Id(s): PR-8926 + + *** HIGHLIGHT *** + +- Documentation chunks (EEP-48) has been updated to include the following + reserved metadata fields: `behaviours`, `group`, `source_path`, and + `source_annos`. The compiler has also been updated to emit this metadata. See + the EEP-48 documentation for more details. + + Own Id: OTP-19306 + Related Id(s): PR-8945, PR-8975 + +- New strict generators have been added for comprehensions. + + The currently existing generators are "relaxed": they ignore terms in the + right-hand side expression that do not match the left-hand side pattern. + + The new strict generators fail with exception `badmatch` if a pattern doesn't + match. + + Examples: + + Using the current relaxed generator operator `<-`, any element not matching + the pattern `{_,_}` will be silently discarded: + + 1> [T || {_,_}=T <- [{ok,1},ok,{error,2}]]. + [{ok,1},{error,2}] + + If the intention is that all lists processed by a list comprehension must only + contain tuples of size two, using the new strict version of the operator + ensures that term not matching will cause a crash: + + 2> [T || {_,_}=T <:- [{ok,1},ok,{error,2}]]. + ** exception error: no match of right hand side value ok + + Using the strict generator operator to mark the intention that all list + elements must match the pattern could help finding mistakes quicker if + something unpexected is added to the list processed by the generator. + + The strict version for bitstring generators is `<:=`. + + Own Id: OTP-19317 + Related Id(s): PR-8625 + + *** HIGHLIGHT *** + +- New options for suppressing behaviour warnings have been added: + + - `nowarn_conflicting_behaviours` + - `nowarn_undefined_behaviour_func` + - `nowarn_undefined_behaviour` + - `nowarn_undefined_behaviour_callbacks` + - `nowarn_ill_defined_behaviour_callbacks` + - `nowarn_ill_defined_optional_callbacks` + + Own Id: OTP-19334 + Related Id(s): GH-8985, PR-9020 + +- Some BIFs with side-effects are optimized in `try`/`catch` in the same way as + guard BIFs in order to gain performance. + + The following BIFs that are optimized in this way: `binary_to_atom/1`, + `binary_to_atom/2`, `binary_to_existing_atom/1`, `list_to_atom/1`, and + `list_to_existing_atom/1`. + + Own Id: OTP-19339 + Related Id(s): PR-9042, PR-9122 + +- The compiler now converts known documentation attribute metadata entries from + unicode:chardata/0 to unicode:unicode_binary/0. + + Own Id: OTP-19394 + Related Id(s): PR-9192 + +- The `warn_deprecated_catch` option enables warnings for use of old-style catch + expressions on the form `catch Expr` instead of the modern + `try ... catch ... end`. To prevent new uses of uses of old catches to be + added, this compiler option can be enabled on the project level and + `-compile(nowarn_deprecated_catch).` added to individual files that still + contain old catches. + + Own Id: OTP-19425 + Related Id(s): PR-9154 + +- Defining a fun in terms of an imported function is not allowed. Before this + release, the compiler would not catch this kind of error if the name of the + imported function happened to be a BIF. Consider this example: + + -module(fun_example). + -export([foo/0, bar/0]). + -import(m, [max/2, not_a_bif/0]). + + foo() -> + fun max/2. + + bar() -> + fun not_a_bif/0. + + The compiler in Erlang/OTP 27 would generate the following messages: + + fun_example.erl:9:5: function not_a_bif/0 undefined + % 9| fun not_a_bif/0. + % | ^ + + fun_example.erl:3:2: Warning: import directive overrides auto-imported BIF max/2 -- + use "-compile({no_auto_import,[max/2]})." to resolve name clash + % 3| -import(m, [max/2, not_a_bif/0]). + % | ^ + + That is, there would be a (cryptic) error for `fun not_a_bif/0`, but only a + warning for `fun max/2`. + + When compiling with this release, both attempts to create a fun will result in + error messages (as well as a warning): + + fun_example.erl:6:5: creating a fun from imported name max/2 is not allowed + % 6| fun max/2. + % | ^ + + fun_example.erl:9:5: creating a fun from imported name not_a_bif/0 is not allowed + % 9| fun not_a_bif/0. + % | ^ + + fun_example.erl:3:2: Warning: import directive overrides auto-imported BIF max/2 -- + use "-compile({no_auto_import,[max/2]})." to resolve name clash + % 3| -import(m, [max/2, not_a_bif/0]). + % | ^ + + Also, attempting to call a local function having the same name as + auto-imported BIF would result in an error if the BIF was added to Erlang/OTP + before R14, and a warning for newer BIFs. This has been changed to always emit + a warning. For example: + + -module(bif_example). + -export([bar/1]). + + bar(B) -> + is_boolean(B). + + is_boolean(B) -> + B =:= true orelse B =:= false. + + will now result in the following warning instead of an error: + + if_example.erl:5:5: Warning: ambiguous call of overridden auto-imported BIF is_boolean/1 -- + use erlang:is_boolean/1 or "-compile({no_auto_import,[is_boolean/1]})." to resolve name clash + % 5| is_boolean(B). + % | ^ + + Own Id: OTP-19432 + Related Id(s): PR-9246 + +> #### Full runtime dependencies of compiler-9.0 +> +> crypto-5.1, erts-13.0, kernel-8.4, stdlib-6.0 + +# crypto-5.6 + +## Improvements and New Features + +- The crypto:start/0, crypto:stop/0, and crypto:enable_fips_mode/1 + functions have been deprecated. + + Own Id: OTP-19155 + Related Id(s): PR-8592 + +- Warnings are now logged if module `crypto` with FIPS-supported OpenSSL is + loaded without application `crypto` being loaded. In this case FIPS will be + disabled even if the user had set application parameter `fips_mode`. + + Own Id: OTP-19156 + Related Id(s): PR-8590 + +- The functionality of crypto:crypto_one_time_aead/6 is now also available in + the new functions crypto:crypto_one_time_aead_init/4 and + crypto:crypto_one_time_aead/4, which makes it possible to reuse + initialization. + + Own Id: OTP-19426 + Related Id(s): PR-9289 + +- Added support for compiling Erlang/OTP for Windows on ARM64. + + Own Id: OTP-19480 + Related Id(s): PR-8734 + +> #### Full runtime dependencies of crypto-5.6 +> +> erts-9.0, kernel-6.0, stdlib-3.9 + +# debugger-6.0 + +## Fixed Bugs and Malfunctions + +- Error handling has been improved when modules fail to load. + + Own Id: OTP-19484 + Related Id(s): GH-7819, PR-9399 + +## Improvements and New Features + +- Comprehensions have been extended with zip generators according to EEP 73. + + Example: + + 1> [A+B || A <- [1,2,3] && B <- [4,5,6]]. + [5,7,9] + + Own Id: OTP-19184 + Related Id(s): PR-8926 + + *** HIGHLIGHT *** + +- New strict generators have been added for comprehensions. + + The currently existing generators are "relaxed": they ignore terms in the + right-hand side expression that do not match the left-hand side pattern. + + The new strict generators fail with exception `badmatch` if a pattern doesn't + match. + + Examples: + + Using the current relaxed generator operator `<-`, any element not matching + the pattern `{_,_}` will be silently discarded: + + 1> [T || {_,_}=T <- [{ok,1},ok,{error,2}]]. + [{ok,1},{error,2}] + + If the intention is that all lists processed by a list comprehension must only + contain tuples of size two, using the new strict version of the operator + ensures that term not matching will cause a crash: + + 2> [T || {_,_}=T <:- [{ok,1},ok,{error,2}]]. + ** exception error: no match of right hand side value ok + + Using the strict generator operator to mark the intention that all list + elements must match the pattern could help finding mistakes quicker if + something unpexected is added to the list processed by the generator. + + The strict version for bitstring generators is `<:=`. + + Own Id: OTP-19317 + Related Id(s): PR-8625 + + *** HIGHLIGHT *** + +> #### Full runtime dependencies of debugger-6.0 +> +> compiler-8.0, erts-15.0, kernel-10.0, stdlib-7.0, wx-2.0 + +# dialyzer-5.4 + +## Fixed Bugs and Malfunctions + +- The `-Wno_unknown` option will now prevent a warning being printed to standard + output when the command line interface is used. + + Own Id: OTP-19262 + Related Id(s): GH-8822, PR-8885 + +## Improvements and New Features + +- EEP-69: Nominal Types has been implemented. As a side effect, nominal types + can encode opaque types. We changed all opaque-handling logic and improved + opaque warnings in Dialyzer. + + All existing Erlang type systems are structural: two types are seen as + equivalent if their structures are the same. Type comparisons are based on the + structures of the types, not on how the user explicitly defines them. For + example, in the following example, `meter()` and `foot()` are equivalent. The + two types can be used interchangeably. Neither of them differ from the basic + type `integer()`. + + -type meter() :: integer(). + -type foot() :: integer(). + + Nominal typing is an alternative type system, where two types are equivalent + if and only if they are declared with the same type name. The EEP proposes one + new syntax -nominal for declaring nominal types. Under nominal typing, + `meter()` and `foot()` are no longer compatible. Whenever a function expects + type `meter()`, passing in type `foot()` would result in a Dialyzer error. + + -nominal meter() :: integer(). + -nominal foot() :: integer(). + + More nominal type-checking rules can be found in the EEP. It is worth noting + that most work for adding nominal types and type-checking is in + `erl_types.erl`. The rest are changes that removed the previous opaque + type-checking, and added an improved version of it using nominal type-checking + with reworked warnings. + + Backwards compatibility for opaque type-checking is not preserved by this PR. + Previous opaque warnings can appear with slightly different wordings. A new + kind of opaque warning `opaque_union` is added, together with a Dialyzer + option `no_opaque_union` to turn this kind of warnings off. + + Own Id: OTP-19364 + Related Id(s): PR-9079 + + *** HIGHLIGHT *** + +> #### Full runtime dependencies of dialyzer-5.4 +> +> compiler-8.0, erts-12.0, kernel-8.0, stdlib-5.0, syntax_tools-2.0 + +# diameter-2.5 + +## Improvements and New Features + +- EEP-69: Nominal Types has been implemented. As a side effect, nominal types + can encode opaque types. We changed all opaque-handling logic and improved + opaque warnings in Dialyzer. + + All existing Erlang type systems are structural: two types are seen as + equivalent if their structures are the same. Type comparisons are based on the + structures of the types, not on how the user explicitly defines them. For + example, in the following example, `meter()` and `foot()` are equivalent. The + two types can be used interchangeably. Neither of them differ from the basic + type `integer()`. + + -type meter() :: integer(). + -type foot() :: integer(). + + Nominal typing is an alternative type system, where two types are equivalent + if and only if they are declared with the same type name. The EEP proposes one + new syntax -nominal for declaring nominal types. Under nominal typing, + `meter()` and `foot()` are no longer compatible. Whenever a function expects + type `meter()`, passing in type `foot()` would result in a Dialyzer error. + + -nominal meter() :: integer(). + -nominal foot() :: integer(). + + More nominal type-checking rules can be found in the EEP. It is worth noting + that most work for adding nominal types and type-checking is in + `erl_types.erl`. The rest are changes that removed the previous opaque + type-checking, and added an improved version of it using nominal type-checking + with reworked warnings. + + Backwards compatibility for opaque type-checking is not preserved by this PR. + Previous opaque warnings can appear with slightly different wordings. A new + kind of opaque warning `opaque_union` is added, together with a Dialyzer + option `no_opaque_union` to turn this kind of warnings off. + + Own Id: OTP-19364 + Related Id(s): PR-9079 + + *** HIGHLIGHT *** + +> #### Full runtime dependencies of diameter-2.5 +> +> erts-10.0, kernel-3.2, ssl-9.0, stdlib-5.0 + +# edoc-1.4 + +## Improvements and New Features + +- EEP-69: Nominal Types has been implemented. As a side effect, nominal types + can encode opaque types. We changed all opaque-handling logic and improved + opaque warnings in Dialyzer. + + All existing Erlang type systems are structural: two types are seen as + equivalent if their structures are the same. Type comparisons are based on the + structures of the types, not on how the user explicitly defines them. For + example, in the following example, `meter()` and `foot()` are equivalent. The + two types can be used interchangeably. Neither of them differ from the basic + type `integer()`. + + -type meter() :: integer(). + -type foot() :: integer(). + + Nominal typing is an alternative type system, where two types are equivalent + if and only if they are declared with the same type name. The EEP proposes one + new syntax -nominal for declaring nominal types. Under nominal typing, + `meter()` and `foot()` are no longer compatible. Whenever a function expects + type `meter()`, passing in type `foot()` would result in a Dialyzer error. + + -nominal meter() :: integer(). + -nominal foot() :: integer(). + + More nominal type-checking rules can be found in the EEP. It is worth noting + that most work for adding nominal types and type-checking is in + `erl_types.erl`. The rest are changes that removed the previous opaque + type-checking, and added an improved version of it using nominal type-checking + with reworked warnings. + + Backwards compatibility for opaque type-checking is not preserved by this PR. + Previous opaque warnings can appear with slightly different wordings. A new + kind of opaque warning `opaque_union` is added, together with a Dialyzer + option `no_opaque_union` to turn this kind of warnings off. + + Own Id: OTP-19364 + Related Id(s): PR-9079 + + *** HIGHLIGHT *** + +> #### Full runtime dependencies of edoc-1.4 +> +> erts-11.0, inets-5.10, kernel-7.0, stdlib-4.0, syntax_tools-2.0, xmerl-1.3.7 + +# eldap-1.2.15 + +## Improvements and New Features + +- Fixed licenses in files and added ORT curations to the following apps: otp, + eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and ERTS. + + Own Id: OTP-19478 + Related Id(s): PR-9376, PR-9402 + +> #### Full runtime dependencies of eldap-1.2.15 +> +> asn1-3.0, erts-6.0, kernel-3.0, ssl-5.3.4, stdlib-3.4 + +# erl_interface-5.6 + +## Improvements and New Features + +- Fixed licenses in files and added ORT curations to the following apps: otp, + eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and ERTS. + + Own Id: OTP-19478 + Related Id(s): PR-9376, PR-9402 + +- Added support for compiling Erlang/OTP for Windows on ARM64. + + Own Id: OTP-19480 + Related Id(s): PR-8734 + +## Known Bugs and Problems + +- The `ei` API for decoding/encoding terms is not fully 64-bit compatible since + terms that have a representation on the external term format larger than 2 GB + cannot be handled. + + Own Id: OTP-16607 + Related Id(s): OTP-16608 + +# erts-16.0 + +## Fixed Bugs and Malfunctions + +- ETS tables with more than 2 billion keys are now supported. + + Own Id: OTP-19144 + Related Id(s): PR-8589 + +- The zlib library included in Erlang/OTP has been updated to version 1.3.1. + + Own Id: OTP-19259 + Related Id(s): PR-8862 + +- `to_erl` no longer clears the screen when attaching to a `run_erl` session. + + Own Id: OTP-19263 + Related Id(s): PR-8943 + +- The size of an atom in the Erlang source code was limited to 255 bytes in + previous releases, meaning that an atom containing only emojis could contain + only 63 emojis. + + While atoms are still only allowed to contain 255 characters, the number of + bytes is no longer limited. + + External tools that parse the `AtU8` chunk of a BEAM file directly need to be + updated. Tools that use + `beam_lib:chunks(Beam, [atoms)`](beam_lib:chunks/2) to read the atom table + will continue to work. + + Own Id: OTP-19285 + Related Id(s): PR-8913 + + *** POTENTIAL INCOMPATIBILITY *** + +- Fixed a bug where `erlc` would crash if its path contained spaces. + + Own Id: OTP-19295 + Related Id(s): PR-8937 + +- The `-noshell` mode has been updated to read data lazily from standard + input. Before this fix any data would be read greedily which meant that Erlang + could consume data not meant for it. It also meant that in order for + shell:start_interactive/0 to work on Windows an API that did not support + reading of Unicode characters had to be used. + + Own Id: OTP-19313 + Related Id(s): GH-8113, PR-8962 + +- The literals chunk in BEAM is no longer compressed, resulting in slightly + smaller BEAM files when a BEAM file is stripped using + beam_lib:strip_files/1. + + This is a potential incompatibility for tools that read and interpret the + contents of the literal chunk. One way to update such tools to work with the + new format is to retrieve the chunk using + `beam_lib:chunks(Beam, [literals)`](beam_lib:chunks/2). + + Own Id: OTP-19323 + Related Id(s): GH-8967, PR-8988 + + *** POTENTIAL INCOMPATIBILITY *** + +- Fixed erlang:localtime_to_universaltime/2 with `IsDST` set to `true` and a + timezone without daylight saving (for example `UTC`) to assume that the + provided localtime does not have DST. This has always been the behaviour, but + glibc versions after 2.37 changed it so that the behavior in Erlang also + changed. + + Own Id: OTP-19453 + Related Id(s): PR-9207 + +- Support for the `TZ` environment variable has been added on Windows. Before + this change only the time zone configured in the OS was ever used. + + Own Id: OTP-19454 + Related Id(s): PR-9207 + +## Improvements and New Features + +- The trace:system/3 function has been added. It has a similar interface as + erlang:system_monitor/2 but it also supports trace sessions. + + Own Id: OTP-19271 + Related Id(s): PR-8660 + +- Added support for `SIGWINCH`, `SIGCONT`, and `SIGINFO` signals to + os:set_signal/2 where available. + + Own Id: OTP-19278 + Related Id(s): PR-8887, PR-8938 + +- The `erl -noshell` mode has been updated to have two sub modes called `raw` + and `cooked`, where `cooked` is the old default behaviour and `raw` can be + used to bypass the line-editing support of the native terminal. Using `raw` + mode it is possible to read keystrokes as they happen without the user having + to press Enter. Also, the `raw` mode does not echo the typed characters to + stdout. An example of how to create a tic-tac-toe game using this mechanism is + included in the documentation. + + Own Id: OTP-19314 + Related Id(s): GH-8037, PR-8962 + + *** HIGHLIGHT *** + +- EEP-69: Nominal Types has been implemented. As a side effect, nominal types + can encode opaque types. We changed all opaque-handling logic and improved + opaque warnings in Dialyzer. + + All existing Erlang type systems are structural: two types are seen as + equivalent if their structures are the same. Type comparisons are based on the + structures of the types, not on how the user explicitly defines them. For + example, in the following example, `meter()` and `foot()` are equivalent. The + two types can be used interchangeably. Neither of them differ from the basic + type `integer()`. + + -type meter() :: integer(). + -type foot() :: integer(). + + Nominal typing is an alternative type system, where two types are equivalent + if and only if they are declared with the same type name. The EEP proposes one + new syntax -nominal for declaring nominal types. Under nominal typing, + `meter()` and `foot()` are no longer compatible. Whenever a function expects + type `meter()`, passing in type `foot()` would result in a Dialyzer error. + + -nominal meter() :: integer(). + -nominal foot() :: integer(). + + More nominal type-checking rules can be found in the EEP. It is worth noting + that most work for adding nominal types and type-checking is in + `erl_types.erl`. The rest are changes that removed the previous opaque + type-checking, and added an improved version of it using nominal type-checking + with reworked warnings. + + Backwards compatibility for opaque type-checking is not preserved by this PR. + Previous opaque warnings can appear with slightly different wordings. A new + kind of opaque warning `opaque_union` is added, together with a Dialyzer + option `no_opaque_union` to turn this kind of warnings off. + + Own Id: OTP-19364 + Related Id(s): PR-9079 + + *** HIGHLIGHT *** + +- Two BIFs have been added to the `erlang` module. + + erlang:processes_iterator/0 returns a process iterator that can be used to + iterate through the process table. + + erlang:process_next/1 takes in a process iterator and returns a 2-tuple, + consisting of a process identifier and a new process iterator. When the + process iterator runs out of processes in the process table, `none` will be + returned. + + Using these BIFs to scan the processes scales better than using + erlang:processes/0, at the cost of giving less consistency guarantees. + Process identifiers returned from consecutive calls of erlang:process_next/1 + may not be a consistent snapshot of all elements existing in the table during + any of the calls. A process identifier is only guaranteed to be returned from + a call to erlang:processes_next/1 if it was alive before the call to + erlang:processes_iterator/0 and was still alive when + erlang:processes_next/1 returned `none`. + + Own Id: OTP-19369 + Related Id(s): PR-9129 + +- Improved open debug for gen_tcp_socket (connect and listen) and gen_udp_socket + (open). + + Own Id: OTP-19386 + +- Module `re` has been updated to use PCRE2, which is mostly backward + compatible with PCRE. + + The most noticeable incompatibilities are + + - The default character encoding is pure ASCII and not Latin1. Unicode support + is still available with options `unicode` and `ucp`. + - Options `bsr_anycrlf`, `bsr_unicode` and `{newline,_}` are only set when a + regex is compiled and cannot be changed at matching for precompiled regex. + + Own Id: OTP-19431 + Related Id(s): PR-9299 + + *** HIGHLIGHT *** + + *** POTENTIAL INCOMPATIBILITY *** + +- When booting the runtime system on a 32-bit computer with a single core, the + boot code will try to minimize the peak memory use by disabling parallel + loading of BEAM files. + + Own Id: OTP-19450 + Related Id(s): PR-9342 + +- A `socket` option `{otp,select_read}` has been added that enables keeping a + socket in the VM select/poll set between calls to recv functions. + + This increases throughput by reducing the number of calls to said functions. + + Own Id: OTP-19451 + Related Id(s): PR-9344 + +- `erlc` will now write compiler warnings and errors to standard error, instead + of standard output, in common with other language compilers. + + Own Id: OTP-19460 + Related Id(s): GH-9255, PR-9363 + +- Fixed the Windows build to always include `.pdb` files for all DLLs and + executables to help with debugging. + + Own Id: OTP-19465 + Related Id(s): PR-9229 + +- Improve the naming of the (internal) esock mutex(es). It is now possible to + configure (as in autoconf) the use of simple names for the esock mutex(es). + + Own Id: OTP-19472 + Related Id(s): #9388 + +- An optimization for appending 0 bits to a binary was removed in patch releases + for OTP versions 25, 26, and 27. This optimization has been reintroduced in + Erlang/OTP 28. + + Own Id: OTP-19473 + Related Id(s): PR-8697, PR-9396 + +- Fixed licenses in files and added ORT curations to the following apps: otp, + eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and ERTS. + + Own Id: OTP-19478 + Related Id(s): PR-9376, PR-9402 + +- When using `enif_select_read` (or `enif_select` with `ERL_NIF_SELECT_READ`) on + systems with kernel polling enabled (that is most Unix systems), file + descriptors that are always re-enabled as soon as they trigger are now part of + a specialized pollset just as `driver_select`. This reduces the CPU usage in + such scenarios as the erts does not have to re-insert the FD everytime it it + triggered. As a result of this optimization `socket` based reading uses a + lot less CPU and achieves a higher throughput. + + Own Id: OTP-19479 + Related Id(s): PR-9275 + +- Added support for compiling Erlang/OTP for Windows on ARM64. + + Own Id: OTP-19480 + Related Id(s): PR-8734 + +- The Windows installer no longer creates the `erl.ini` file, making + installations redistributable. + + Own Id: OTP-19481 + Related Id(s): PR-9330 + +> #### Full runtime dependencies of erts-16.0 +> +> kernel-9.0, sasl-3.3, stdlib-4.1 + +# eunit-2.10 + +## Improvements and New Features + +- EEP-69: Nominal Types has been implemented. As a side effect, nominal types + can encode opaque types. We changed all opaque-handling logic and improved + opaque warnings in Dialyzer. + + All existing Erlang type systems are structural: two types are seen as + equivalent if their structures are the same. Type comparisons are based on the + structures of the types, not on how the user explicitly defines them. For + example, in the following example, `meter()` and `foot()` are equivalent. The + two types can be used interchangeably. Neither of them differ from the basic + type `integer()`. + + -type meter() :: integer(). + -type foot() :: integer(). + + Nominal typing is an alternative type system, where two types are equivalent + if and only if they are declared with the same type name. The EEP proposes one + new syntax -nominal for declaring nominal types. Under nominal typing, + `meter()` and `foot()` are no longer compatible. Whenever a function expects + type `meter()`, passing in type `foot()` would result in a Dialyzer error. + + -nominal meter() :: integer(). + -nominal foot() :: integer(). + + More nominal type-checking rules can be found in the EEP. It is worth noting + that most work for adding nominal types and type-checking is in + `erl_types.erl`. The rest are changes that removed the previous opaque + type-checking, and added an improved version of it using nominal type-checking + with reworked warnings. + + Backwards compatibility for opaque type-checking is not preserved by this PR. + Previous opaque warnings can appear with slightly different wordings. A new + kind of opaque warning `opaque_union` is added, together with a Dialyzer + option `no_opaque_union` to turn this kind of warnings off. + + Own Id: OTP-19364 + Related Id(s): PR-9079 + + *** HIGHLIGHT *** + +- Fixed licenses in files and added ORT curations to the following apps: otp, + eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and ERTS. + + Own Id: OTP-19478 + Related Id(s): PR-9376, PR-9402 + +> #### Full runtime dependencies of eunit-2.10 +> +> erts-9.0, kernel-5.3, stdlib-3.4 + +# inets-9.3.2 + +## Fixed Bugs and Malfunctions + +- Replaced calls to deprecated `crypto:start()` with + `application:start(crypto)`. + + Own Id: OTP-19485 + Related Id(s): PR-8592 + +> #### Full runtime dependencies of inets-9.3.2 +> +> erts-14.0, kernel-9.0, mnesia-4.12, public_key-1.13, runtime_tools-1.8.14, +> ssl-9.0, stdlib-5.0, stdlib-6.0 + +# jinterface-1.15 + +## Improvements and New Features + +- The `.class` files of jinterface are now part of the prebuilt archive using + Java 8. + + Own Id: OTP-19308 + Related Id(s): PR-8960 + +# kernel-10.3 + +## Fixed Bugs and Malfunctions + +- Fixed an issue where output to the shell would not print the prompt on a new + line. + + Own Id: OTP-19228 + Related Id(s): PR-8820 + +- When in `shell` is in `-noshell` mode, and in `latin1` encoding mode, io + requests in latin1 encoding will not be translated to unicode and back to + latin1. + + Own Id: OTP-19296 + Related Id(s): PR-9013 + +- Fixed a bug where a composing unicode character would bind to a character not + available to the user and deleting that character would cause a crash. + + Own Id: OTP-19297 + Related Id(s): PR-9005 + +- The `-noshell` mode has been updated to read data lazily from standard + input. Before this fix any data would be read greedily which meant that Erlang + could consume data not meant for it. It also meant that in order for + shell:start_interactive/0 to work on Windows an API that did not support + reading of Unicode characters had to be used. + + Own Id: OTP-19313 + Related Id(s): GH-8113, PR-8962 + +- The Erlang shell no longer crashes when a shell prompt ends with an escape + sequence. + + Own Id: OTP-19414 + Related Id(s): PR-9272 + +## Improvements and New Features + +- application:load/1 slows down as the number of directories in the code path + increases because the call to code:where_is_file/1 for the '.app' file must + scan each directory for the app. + + `code_server` maintains a cache of the contents of directories in the path. + Re-using that cache when searching for '.app' files in application:load/1 + may improve its runtime, especially when loading multiple applications. + + Own Id: OTP-19194 + Related Id(s): PR-8078 + +- The `Erlang SSH daemon` now uses the same backend to handle multiline + functionality as the Erlang shell. + + Own Id: OTP-19226 + Related Id(s): PR-8805 + +- Added support for `SIGWINCH`, `SIGCONT`, and `SIGINFO` signals to + os:set_signal/2 where available. + + Own Id: OTP-19278 + Related Id(s): PR-8887, PR-8938 + +- Add net_kernel:allowed/0, it returns a list of nodes that are explicitly + allowed to connect to the node by calling net_kernel:allow/1 + + Own Id: OTP-19287 + Related Id(s): PR-8207 + +- Documentation chunks (EEP-48) has been updated to include the following + reserved metadata fields: `behaviours`, `group`, `source_path`, and + `source_annos`. The compiler has also been updated to emit this metadata. See + the EEP-48 documentation for more details. + + Own Id: OTP-19306 + Related Id(s): PR-8945, PR-8975 + +- The erpc:call/3, erpc:call/5, erpc:multicall/3, and erpc:multicall/5 + functions now also accept an option map as last argument containing the + `timeout` and `always_spawn` options. The `always_spawn` option can be used in + order to ensure that the call operation will use a newly spawned process when + executing the remote call. + + Own Id: OTP-19343 + Related Id(s): PR-8642 + +- EEP-69: Nominal Types has been implemented. As a side effect, nominal types + can encode opaque types. We changed all opaque-handling logic and improved + opaque warnings in Dialyzer. + + All existing Erlang type systems are structural: two types are seen as + equivalent if their structures are the same. Type comparisons are based on the + structures of the types, not on how the user explicitly defines them. For + example, in the following example, `meter()` and `foot()` are equivalent. The + two types can be used interchangeably. Neither of them differ from the basic + type `integer()`. + + -type meter() :: integer(). + -type foot() :: integer(). + + Nominal typing is an alternative type system, where two types are equivalent + if and only if they are declared with the same type name. The EEP proposes one + new syntax -nominal for declaring nominal types. Under nominal typing, + `meter()` and `foot()` are no longer compatible. Whenever a function expects + type `meter()`, passing in type `foot()` would result in a Dialyzer error. + + -nominal meter() :: integer(). + -nominal foot() :: integer(). + + More nominal type-checking rules can be found in the EEP. It is worth noting + that most work for adding nominal types and type-checking is in + `erl_types.erl`. The rest are changes that removed the previous opaque + type-checking, and added an improved version of it using nominal type-checking + with reworked warnings. + + Backwards compatibility for opaque type-checking is not preserved by this PR. + Previous opaque warnings can appear with slightly different wordings. A new + kind of opaque warning `opaque_union` is added, together with a Dialyzer + option `no_opaque_union` to turn this kind of warnings off. + + Own Id: OTP-19364 + Related Id(s): PR-9079 + + *** HIGHLIGHT *** + +- Improved open debug for gen_tcp_socket (connect and listen) and gen_udp_socket + (open). + + Own Id: OTP-19386 + +- `t:io:standard_error/0` has been updated to write via a NIF API instead of a + port. This allows it to access the dirty-scheduler pool and make sure that + writes have been written to the OSs `stderr` when io:format/3 and equivalent + return. + + Own Id: OTP-19401 + Related Id(s): PR-9116 + +- Added the option `exception_on_failure` to os:cmd/2 to make os:cmd/2 raise + an exception if the command fails to execute. + + Own Id: OTP-19404 + Related Id(s): PR-9082 + +- A `socket` option `{otp,select_read}` has been added that enables keeping a + socket in the VM select/poll set between calls to recv functions. + + This increases throughput by reducing the number of calls to said functions. + + Own Id: OTP-19451 + Related Id(s): PR-9344 + +> #### Full runtime dependencies of kernel-10.3 +> +> crypto-5.0, erts-15.1, sasl-3.0, stdlib-6.0 + +# megaco-4.8 + +## Improvements and New Features + +- Nano seconds are now used for (example) meas result presentation. + + Nanoseconds are now used, for example, in `meas` result presentations. + + Own Id: OTP-19403 + +- Added support for compiling Erlang/OTP for Windows on ARM64. + + Own Id: OTP-19480 + Related Id(s): PR-8734 + +> #### Full runtime dependencies of megaco-4.8 +> +> asn1-3.0, debugger-4.0, erts-12.0, et-1.5, kernel-8.0, runtime_tools-1.8.14, +> stdlib-2.5 + +# mnesia-4.24 + +## Improvements and New Features + +- EEP-69: Nominal Types has been implemented. As a side effect, nominal types + can encode opaque types. We changed all opaque-handling logic and improved + opaque warnings in Dialyzer. + + All existing Erlang type systems are structural: two types are seen as + equivalent if their structures are the same. Type comparisons are based on the + structures of the types, not on how the user explicitly defines them. For + example, in the following example, `meter()` and `foot()` are equivalent. The + two types can be used interchangeably. Neither of them differ from the basic + type `integer()`. + + -type meter() :: integer(). + -type foot() :: integer(). + + Nominal typing is an alternative type system, where two types are equivalent + if and only if they are declared with the same type name. The EEP proposes one + new syntax -nominal for declaring nominal types. Under nominal typing, + `meter()` and `foot()` are no longer compatible. Whenever a function expects + type `meter()`, passing in type `foot()` would result in a Dialyzer error. + + -nominal meter() :: integer(). + -nominal foot() :: integer(). + + More nominal type-checking rules can be found in the EEP. It is worth noting + that most work for adding nominal types and type-checking is in + `erl_types.erl`. The rest are changes that removed the previous opaque + type-checking, and added an improved version of it using nominal type-checking + with reworked warnings. + + Backwards compatibility for opaque type-checking is not preserved by this PR. + Previous opaque warnings can appear with slightly different wordings. A new + kind of opaque warning `opaque_union` is added, together with a Dialyzer + option `no_opaque_union` to turn this kind of warnings off. + + Own Id: OTP-19364 + Related Id(s): PR-9079 + + *** HIGHLIGHT *** + +> #### Full runtime dependencies of mnesia-4.24 +> +> erts-9.0, kernel-5.3, stdlib-5.0 + +# odbc-2.16 + +## Improvements and New Features + +- Updated odbc configure to enable easier use of iodbc driver. + + Own Id: OTP-19456 + Related Id(s): PR-9083 + +- Added support for compiling Erlang/OTP for Windows on ARM64. + + Own Id: OTP-19480 + Related Id(s): PR-8734 + +> #### Full runtime dependencies of odbc-2.16 +> +> erts-6.0, kernel-3.0, stdlib-2.0 + +# os_mon-2.11 + +## Improvements and New Features + +- `m:disksup` will now recognize HAMMER2 volumes. + + Own Id: OTP-19207 + Related Id(s): PR-8704 + +> #### Full runtime dependencies of os_mon-2.11 +> +> erts-14.0, kernel-9.0, sasl-4.2.1, stdlib-5.0 + +# parsetools-2.7 + +## Improvements and New Features + +- EEP-69: Nominal Types has been implemented. As a side effect, nominal types + can encode opaque types. We changed all opaque-handling logic and improved + opaque warnings in Dialyzer. + + All existing Erlang type systems are structural: two types are seen as + equivalent if their structures are the same. Type comparisons are based on the + structures of the types, not on how the user explicitly defines them. For + example, in the following example, `meter()` and `foot()` are equivalent. The + two types can be used interchangeably. Neither of them differ from the basic + type `integer()`. + + -type meter() :: integer(). + -type foot() :: integer(). + + Nominal typing is an alternative type system, where two types are equivalent + if and only if they are declared with the same type name. The EEP proposes one + new syntax -nominal for declaring nominal types. Under nominal typing, + `meter()` and `foot()` are no longer compatible. Whenever a function expects + type `meter()`, passing in type `foot()` would result in a Dialyzer error. + + -nominal meter() :: integer(). + -nominal foot() :: integer(). + + More nominal type-checking rules can be found in the EEP. It is worth noting + that most work for adding nominal types and type-checking is in + `erl_types.erl`. The rest are changes that removed the previous opaque + type-checking, and added an improved version of it using nominal type-checking + with reworked warnings. + + Backwards compatibility for opaque type-checking is not preserved by this PR. + Previous opaque warnings can appear with slightly different wordings. A new + kind of opaque warning `opaque_union` is added, together with a Dialyzer + option `no_opaque_union` to turn this kind of warnings off. + + Own Id: OTP-19364 + Related Id(s): PR-9079 + + *** HIGHLIGHT *** + +- Fixed licenses in files and added ORT curations to the following apps: otp, + eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and ERTS. + + Own Id: OTP-19478 + Related Id(s): PR-9376, PR-9402 + +> #### Full runtime dependencies of parsetools-2.7 +> +> erts-6.0, kernel-3.0, stdlib-3.4 + +# runtime_tools-2.2 + +## Improvements and New Features + +- EEP-69: Nominal Types has been implemented. As a side effect, nominal types + can encode opaque types. We changed all opaque-handling logic and improved + opaque warnings in Dialyzer. + + All existing Erlang type systems are structural: two types are seen as + equivalent if their structures are the same. Type comparisons are based on the + structures of the types, not on how the user explicitly defines them. For + example, in the following example, `meter()` and `foot()` are equivalent. The + two types can be used interchangeably. Neither of them differ from the basic + type `integer()`. + + -type meter() :: integer(). + -type foot() :: integer(). + + Nominal typing is an alternative type system, where two types are equivalent + if and only if they are declared with the same type name. The EEP proposes one + new syntax -nominal for declaring nominal types. Under nominal typing, + `meter()` and `foot()` are no longer compatible. Whenever a function expects + type `meter()`, passing in type `foot()` would result in a Dialyzer error. + + -nominal meter() :: integer(). + -nominal foot() :: integer(). + + More nominal type-checking rules can be found in the EEP. It is worth noting + that most work for adding nominal types and type-checking is in + `erl_types.erl`. The rest are changes that removed the previous opaque + type-checking, and added an improved version of it using nominal type-checking + with reworked warnings. + + Backwards compatibility for opaque type-checking is not preserved by this PR. + Previous opaque warnings can appear with slightly different wordings. A new + kind of opaque warning `opaque_union` is added, together with a Dialyzer + option `no_opaque_union` to turn this kind of warnings off. + + Own Id: OTP-19364 + Related Id(s): PR-9079 + + *** HIGHLIGHT *** + +> #### Full runtime dependencies of runtime_tools-2.2 +> +> erts-15.0, kernel-10.0, mnesia-4.12, stdlib-6.0 + +# sasl-4.3 + +## Fixed Bugs and Malfunctions + +- Fixed the documentation for the ExtraFiles option to systools:make_tar/2. + + Own Id: OTP-19279 + Related Id(s): GH-8842, PR-8894 + +## Improvements and New Features + +- `.appup` files are now included in releases in order to make it possible to + create upgrade packages from an installed release. + + Own Id: OTP-19398 + Related Id(s): PR-8973 + +> #### Full runtime dependencies of sasl-4.3 +> +> erts-15.0, kernel-6.0, stdlib-4.0, tools-2.6.14 + +# snmp-5.19 + +## Improvements and New Features + +- EEP-69: Nominal Types has been implemented. As a side effect, nominal types + can encode opaque types. We changed all opaque-handling logic and improved + opaque warnings in Dialyzer. + + All existing Erlang type systems are structural: two types are seen as + equivalent if their structures are the same. Type comparisons are based on the + structures of the types, not on how the user explicitly defines them. For + example, in the following example, `meter()` and `foot()` are equivalent. The + two types can be used interchangeably. Neither of them differ from the basic + type `integer()`. + + -type meter() :: integer(). + -type foot() :: integer(). + + Nominal typing is an alternative type system, where two types are equivalent + if and only if they are declared with the same type name. The EEP proposes one + new syntax -nominal for declaring nominal types. Under nominal typing, + `meter()` and `foot()` are no longer compatible. Whenever a function expects + type `meter()`, passing in type `foot()` would result in a Dialyzer error. + + -nominal meter() :: integer(). + -nominal foot() :: integer(). + + More nominal type-checking rules can be found in the EEP. It is worth noting + that most work for adding nominal types and type-checking is in + `erl_types.erl`. The rest are changes that removed the previous opaque + type-checking, and added an improved version of it using nominal type-checking + with reworked warnings. + + Backwards compatibility for opaque type-checking is not preserved by this PR. + Previous opaque warnings can appear with slightly different wordings. A new + kind of opaque warning `opaque_union` is added, together with a Dialyzer + option `no_opaque_union` to turn this kind of warnings off. + + Own Id: OTP-19364 + Related Id(s): PR-9079 + + *** HIGHLIGHT *** + +- Added support for compiling Erlang/OTP for Windows on ARM64. + + Own Id: OTP-19480 + Related Id(s): PR-8734 + +> #### Full runtime dependencies of snmp-5.19 +> +> crypto-4.6, erts-12.0, kernel-8.0, mnesia-4.12, runtime_tools-1.8.14, +> stdlib-5.0 + +# ssh-5.3 + +## Fixed Bugs and Malfunctions + +- The implementation of the ssh server-side supervision tree has been improved. + + Own Id: OTP-19324 + Related Id(s): GH-8223, PR-8968 + +## Improvements and New Features + +- The `Erlang SSH daemon` now uses the same backend to handle multiline + functionality as the Erlang shell. + + Own Id: OTP-19226 + Related Id(s): PR-8805 + +- CBC algorithms are not offered by default. See Configuring algorithms in SSH + if you wish to enable them. + + Own Id: OTP-19420 + Related Id(s): PR-9277 + + *** POTENTIAL INCOMPATIBILITY *** + +> #### Full runtime dependencies of ssh-5.3 +> +> crypto-5.0, erts-14.0, kernel-10.3, public_key-1.6.1, runtime_tools-1.15.1, +> stdlib-5.0, stdlib-6.0 + +# ssl-11.3 + +## Improvements and New Features + +- Refactoring, minor optimizations and improved log printouts. + + Own Id: OTP-19367 + Related Id(s): PR-9019 + +- supervisor:which_child/2 is now used to make start-up code for + TLS-connections simpler and more straight forward, and to increase stability + and maintainability of the ssl application. + + Own Id: OTP-19406 + Related Id(s): PR-9231 + +- The data handling for tls-v1.3 has been optimized. + + Own Id: OTP-19430 + Related Id(s): PR-9305 + +- Added experimental socket support. + + Own Id: OTP-19463 + Related Id(s): PR-9398 + +> #### Full runtime dependencies of ssl-11.3 +> +> crypto-5.6, erts-16.0, inets-5.10.7, kernel-10.3, public_key-1.16.4, +> runtime_tools-1.15.1, stdlib-7.0 + +# stdlib-7.0 + +## Fixed Bugs and Malfunctions + +- Shell help now orders the commands in alphabetical order. + + Own Id: OTP-19161 + Related Id(s): PR-8573 + +- `proc_lib:stop/1,3` (and in extension gen_server:stop/3, gen_statem:stop/3 + and so on) have been updated to not throw an error if the process to be + stopped exits with the same reason as given to proc_lib:stop/3. + + Own Id: OTP-19233 + Related Id(s): PR-8772 + + *** POTENTIAL INCOMPATIBILITY *** + +- The size of an atom in the Erlang source code was limited to 255 bytes in + previous releases, meaning that an atom containing only emojis could contain + only 63 emojis. + + While atoms are still only allowed to contain 255 characters, the number of + bytes is no longer limited. + + External tools that parse the `AtU8` chunk of a BEAM file directly need to be + updated. Tools that use + `beam_lib:chunks(Beam, [atoms)`](beam_lib:chunks/2) to read the atom table + will continue to work. + + Own Id: OTP-19285 + Related Id(s): PR-8913 + + *** POTENTIAL INCOMPATIBILITY *** + +- argparse:help/1 now accepts unicode:chardata/0. + + Own Id: OTP-19303 + Related Id(s): PR-8932 + +- The literals chunk in BEAM is no longer compressed, resulting in slightly + smaller BEAM files when a BEAM file is stripped using + beam_lib:strip_files/1. + + This is a potential incompatibility for tools that read and interpret the + contents of the literal chunk. One way to update such tools to work with the + new format is to retrieve the chunk using + `beam_lib:chunks(Beam, [literals)`](beam_lib:chunks/2). + + Own Id: OTP-19323 + Related Id(s): GH-8967, PR-8988 + + *** POTENTIAL INCOMPATIBILITY *** + +- The previous digraph_utils:preorder/1 and digraph_utils:postorder/1 did + not start the traversal from root nodes. This fix makes both traversals only + start or restart from a root node in one of the components, or an arbitrary + node if no root node can be visited. + + Own Id: OTP-19393 + Related Id(s): PR-9171 + +- Auto-completion in the shell is now significantly faster for function + parameters that uses complex custom types. + + Own Id: OTP-19413 + Related Id(s): PR-9271 + +- Stringfying a non-latin1 atom will now produce a readable string instead of + encoding each character using `\x{...}` escape sequences. Example: + + -define(S(T), ??T). + + atom() -> + ?S('атом'). + + The `atom/0` function now returns `"'атом'"` instead of + `"'\\x{430}\\x{442}\\x{43E}\\x{43C}'"`. + + Own Id: OTP-19421 + Related Id(s): GH-9173, PR-9276 + +- A few minor issues were corrected in `syntax_tools`, as well in the + `erl_anno` module. + + Own Id: OTP-19422 + Related Id(s): PR-9253 + +- `m:dets` could print error messages to standard output when repairing DETS + files. This has been changed to send the messages to the error logger. + + `ets:fun2ms` would print an error message to standard output as well as + returning an error tuple. The printing of the message has been removed. + + Own Id: OTP-19427 + Related Id(s): PR-9232 + +- The functions for converting to and from the RFC1339 date and time format + would not properly handle fractional seconds for negative times. + + Own Id: OTP-19441 + Related Id(s): GH-9279, PR-9280 + +- Replaced calls to deprecated `crypto:start()` with + `application:start(crypto)`. + + Own Id: OTP-19485 + Related Id(s): PR-8592 + +## Improvements and New Features + +- Singleton type variables in an union type do not make sense from Dialyzer's + point of view. The following example is ill-typed: + + -spec run_test(Opts) -> term() + when Opts :: {join_specs, Bool} | {test, Bool}. + + This used to be reported as a warning. In OTP-28, this is an error + + Own Id: OTP-19125 + Related Id(s): PR-8556 + +- By default, sets created by the `sets` module will now be represented as + maps. + + Own Id: OTP-19127 + Related Id(s): PR-8429 + +- For various error types, the compiler now tries to suggest potential fixes by + adding "did you mean ...?" at the end of error messages. + + When a function is used with wrong arity, the compiler will try to suggest a + defined function with the same name but a different arity. For example, given + the following module: + + -module(typos). + -export([t/0]). + bar(A) -> A. + bar(A,A,A) -> A. + bar(A,A,A,A) -> A. + t() -> bar(0, 0). + + The compiler will emit the following message: + + typo.erl:6:12: function bar/2 undefined, did you mean bar/1,3,4? + % 6| t() -> bar(0, 0). + % | ^ + + For compiler errors that can easily be caused by typos, the compiler will try + to suggest what the correct variable or function name, could be. For example, + given the following module: + + -module(typos). + -export([bar/2]). + + bar(A0, B0) -> + A + B. + + the compiler will emit the following error messages: + + typos.erl:5:5: variable 'A' is unbound, did you mean 'A0'? + % 5| A + B. + % | ^ + + typos.erl:5:9: variable 'B' is unbound, did you mean 'B0'? + % 5| A + B. + % | ^ + + Error types that now suggest correct arities: `bad_inline`, `undefined_nif`, + `bad_nowarn_unused_function`, `bad_nowarn_bif_clash`, `undefined_function`. + + Error types that now suggest correct names: `bad_inline`, `undefined_nif`, + `bad_nowarn_unused_function`, `undefined_on_load`, `undefined_function`, + `undefined_record`, `undefined_field`, `unbound_var`. + + Using a function with wrong arity has higher precedence than having a typo in + the function name. If the compiler can find a defined function with the same + name but a different arity, it will not suggest a defined function with a + close-enough name, regardless of arity. + + Own Id: OTP-19180 + Related Id(s): PR-8699, PR-9094 + + *** HIGHLIGHT *** + +- Comprehensions have been extended with zip generators according to EEP 73. + + Example: + + 1> [A+B || A <- [1,2,3] && B <- [4,5,6]]. + [5,7,9] + + Own Id: OTP-19184 + Related Id(s): PR-8926 + + *** HIGHLIGHT *** + +- Before restarting a child, a supervisor must check if the restart limit is + reached. This adds a penalty to the overall restart time, which should be kept + low. The algorithm has been optimized from 2\*O(n) to O(n) behavior. + + Own Id: OTP-19204 + Related Id(s): PR-8261 + +- Added the possibility to configure shell docs column width through the stdlib + parameter `shell_docs_columns`. + + Own Id: OTP-19224 + Related Id(s): PR-8651 + +- The io:setopts/2 function now accepts the `line_history` option for more + explicit handling of when to save shell history. + + Own Id: OTP-19230 + Related Id(s): PR-8792 + +- The shell now prints a help message explaining how to interrupt a running + command when stuck executing a command for longer than 5 seconds. + + Own Id: OTP-19231 + Related Id(s): PR-8793 + +- Binaries can now be used as input to calendar:rfc3339_to_system_time/2, and + produced as output of calendar:system_time_to_rfc3339/2. + + Own Id: OTP-19250 + Related Id(s): PR-8812 + +- The `erl -noshell` mode has been updated to have two sub modes called `raw` + and `cooked`, where `cooked` is the old default behaviour and `raw` can be + used to bypass the line-editing support of the native terminal. Using `raw` + mode it is possible to read keystrokes as they happen without the user having + to press Enter. Also, the `raw` mode does not echo the typed characters to + stdout. An example of how to create a tic-tac-toe game using this mechanism is + included in the documentation. + + Own Id: OTP-19314 + Related Id(s): GH-8037, PR-8962 + + *** HIGHLIGHT *** + +- Added io:get_password/0 that can read passwords from stdin when in "raw" + `-noshell` mode. + + Own Id: OTP-19315 + Related Id(s): PR-8962, PR-9006 + +- New strict generators have been added for comprehensions. + + The currently existing generators are "relaxed": they ignore terms in the + right-hand side expression that do not match the left-hand side pattern. + + The new strict generators fail with exception `badmatch` if a pattern doesn't + match. + + Examples: + + Using the current relaxed generator operator `<-`, any element not matching + the pattern `{_,_}` will be silently discarded: + + 1> [T || {_,_}=T <- [{ok,1},ok,{error,2}]]. + [{ok,1},{error,2}] + + If the intention is that all lists processed by a list comprehension must only + contain tuples of size two, using the new strict version of the operator + ensures that term not matching will cause a crash: + + 2> [T || {_,_}=T <:- [{ok,1},ok,{error,2}]]. + ** exception error: no match of right hand side value ok + + Using the strict generator operator to mark the intention that all list + elements must match the pattern could help finding mistakes quicker if + something unpexected is added to the list processed by the generator. + + The strict version for bitstring generators is `<:=`. + + Own Id: OTP-19317 + Related Id(s): PR-8625 + + *** HIGHLIGHT *** + +- New options for suppressing behaviour warnings have been added: + + - `nowarn_conflicting_behaviours` + - `nowarn_undefined_behaviour_func` + - `nowarn_undefined_behaviour` + - `nowarn_undefined_behaviour_callbacks` + - `nowarn_ill_defined_behaviour_callbacks` + - `nowarn_ill_defined_optional_callbacks` + + Own Id: OTP-19334 + Related Id(s): GH-8985, PR-9020 + +- The `join(Binaries, Separator)` function that joins a list of binaries has + been added to the `binary` module. + + Own Id: OTP-19337 + Related Id(s): GH-8099, PR-8100 + + *** HIGHLIGHT *** + +- The supervisor:which_child/2 function has been added to facilitate getting + the pid of a sibling process; that is a process under same supervisor as the + process that calls to call the new function. + + Own Id: OTP-19345 + Related Id(s): PR-8976 + +- The function erl_anno:set_end_location/2 for setting the end location of a + token has been added. + + Own Id: OTP-19354 + Related Id(s): PR-8966 + +- Added a warning for calling non-exported functions with the remote function + call syntax from the same module, and likewise for the remote fun syntax. + + Own Id: OTP-19371 + Related Id(s): GH-9092, PR-9095 + +- The `warn_deprecated_catch` option enables warnings for use of old-style catch + expressions on the form `catch Expr` instead of the modern + `try ... catch ... end`. To prevent new uses of uses of old catches to be + added, this compiler option can be enabled on the project level and + `-compile(nowarn_deprecated_catch).` added to individual files that still + contain old catches. + + Own Id: OTP-19425 + Related Id(s): PR-9154 + +- Module `re` has been updated to use PCRE2, which is mostly backward + compatible with PCRE. + + The most noticeable incompatibilities are + + - The default character encoding is pure ASCII and not Latin1. Unicode support + is still available with options `unicode` and `ucp`. + - Options `bsr_anycrlf`, `bsr_unicode` and `{newline,_}` are only set when a + regex is compiled and cannot be changed at matching for precompiled regex. + + Own Id: OTP-19431 + Related Id(s): PR-9299 + + *** HIGHLIGHT *** + + *** POTENTIAL INCOMPATIBILITY *** + +- Defining a fun in terms of an imported function is not allowed. Before this + release, the compiler would not catch this kind of error if the name of the + imported function happened to be a BIF. Consider this example: + + -module(fun_example). + -export([foo/0, bar/0]). + -import(m, [max/2, not_a_bif/0]). + + foo() -> + fun max/2. + + bar() -> + fun not_a_bif/0. + + The compiler in Erlang/OTP 27 would generate the following messages: + + fun_example.erl:9:5: function not_a_bif/0 undefined + % 9| fun not_a_bif/0. + % | ^ + + fun_example.erl:3:2: Warning: import directive overrides auto-imported BIF max/2 -- + use "-compile({no_auto_import,[max/2]})." to resolve name clash + % 3| -import(m, [max/2, not_a_bif/0]). + % | ^ + + That is, there would be a (cryptic) error for `fun not_a_bif/0`, but only a + warning for `fun max/2`. + + When compiling with this release, both attempts to create a fun will result in + error messages (as well as a warning): + + fun_example.erl:6:5: creating a fun from imported name max/2 is not allowed + % 6| fun max/2. + % | ^ + + fun_example.erl:9:5: creating a fun from imported name not_a_bif/0 is not allowed + % 9| fun not_a_bif/0. + % | ^ + + fun_example.erl:3:2: Warning: import directive overrides auto-imported BIF max/2 -- + use "-compile({no_auto_import,[max/2]})." to resolve name clash + % 3| -import(m, [max/2, not_a_bif/0]). + % | ^ + + Also, attempting to call a local function having the same name as + auto-imported BIF would result in an error if the BIF was added to Erlang/OTP + before R14, and a warning for newer BIFs. This has been changed to always emit + a warning. For example: + + -module(bif_example). + -export([bar/1]). + + bar(B) -> + is_boolean(B). + + is_boolean(B) -> + B =:= true orelse B =:= false. + + will now result in the following warning instead of an error: + + if_example.erl:5:5: Warning: ambiguous call of overridden auto-imported BIF is_boolean/1 -- + use erlang:is_boolean/1 or "-compile({no_auto_import,[is_boolean/1]})." to resolve name clash + % 5| is_boolean(B). + % | ^ + + Own Id: OTP-19432 + Related Id(s): PR-9246 + +- It is now possible to use any base for floating point numbers as described in + EEP 75: Based Floating Point Literals. + + Computers represent floating point numbers in binary, but such numbers are + typically printed using base ten, for example 0.314159265e1. To maintain exact + bit-level precision when converting numbers to and from text, it is better to + use a base that matches the internally used base, such as 16 for a compact but + still exact representation, or 2 for visualizing or writing down the exact + internal format. One particular case where such exact representations are + useful is in code generating tools. + + Examples: + + > 2#0.111. + 0.875 + > 16#fefe.fefe#e16. + 1.2041849337671418e24 + + Own Id: OTP-19452 + Related Id(s): PR-9106 + + *** HIGHLIGHT *** + +- The callback function `handle_continue/2` in `gen_server` callback modules is + now cached like the others, thanks to code cleanup and optimization of the + internal behaviour loop. + + This should only improve performance, not affect functionality. + + Own Id: OTP-19474 + Related Id(s): PR-9333 + +- Encoding done by the `json` module has been optimized. + + Own Id: OTP-19476 + Related Id(s): PR-9251 + +- There is a new `zstd` module that does Zstandard compression. + + Own Id: OTP-19477 + Related Id(s): PR-9316 + + *** HIGHLIGHT *** + +- Fixed licenses in files and added ORT curations to the following apps: otp, + eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and ERTS. + + Own Id: OTP-19478 + Related Id(s): PR-9376, PR-9402 + +> #### Full runtime dependencies of stdlib-7.0 +> +> compiler-5.0, crypto-4.5, erts-15.0, kernel-10.0, sasl-3.0, syntax_tools-3.2.1 + +# syntax_tools-4.0 + +## Fixed Bugs and Malfunctions + +- A few minor issues were corrected in `syntax_tools`, as well in the + `erl_anno` module. + + Own Id: OTP-19422 + Related Id(s): PR-9253 + +## Improvements and New Features + +- Comprehensions have been extended with zip generators according to EEP 73. + + Example: + + 1> [A+B || A <- [1,2,3] && B <- [4,5,6]]. + [5,7,9] + + Own Id: OTP-19184 + Related Id(s): PR-8926 + + *** HIGHLIGHT *** + +- New strict generators have been added for comprehensions. + + The currently existing generators are "relaxed": they ignore terms in the + right-hand side expression that do not match the left-hand side pattern. + + The new strict generators fail with exception `badmatch` if a pattern doesn't + match. + + Examples: + + Using the current relaxed generator operator `<-`, any element not matching + the pattern `{_,_}` will be silently discarded: + + 1> [T || {_,_}=T <- [{ok,1},ok,{error,2}]]. + [{ok,1},{error,2}] + + If the intention is that all lists processed by a list comprehension must only + contain tuples of size two, using the new strict version of the operator + ensures that term not matching will cause a crash: + + 2> [T || {_,_}=T <:- [{ok,1},ok,{error,2}]]. + ** exception error: no match of right hand side value ok + + Using the strict generator operator to mark the intention that all list + elements must match the pattern could help finding mistakes quicker if + something unpexected is added to the list processed by the generator. + + The strict version for bitstring generators is `<:=`. + + Own Id: OTP-19317 + Related Id(s): PR-8625 + + *** HIGHLIGHT *** + +- Fixed licenses in files and added ORT curations to the following apps: otp, + eldap, erl_interface, eunit, parsetools, stdlib, syntax_tools, and ERTS. + + Own Id: OTP-19478 + Related Id(s): PR-9376, PR-9402 + +> #### Full runtime dependencies of syntax_tools-4.0 +> +> compiler-9.0, erts-16.0, kernel-10.3, stdlib-7.0 + +# tools-4.1.2 + +## Fixed Bugs and Malfunctions + +- A crash has been eliminated in tprof:collect/0 when unloading a module while + collecting traces. + + Own Id: OTP-19135 + Related Id(s): GH-8483, PR-8547 + +- Improved the `indent-region` Emacs command, which could indent badly when + inside multiline string. + + Own Id: OTP-19396 + Related Id(s): PR-9186 + +- eprof:start_profiling/3 can now return information about which process it + failed to trace. + + Own Id: OTP-19419 + Related Id(s): PR-9219 + +> #### Full runtime dependencies of tools-4.1.2 +> +> compiler-8.5, erts-15.0, erts-15.0, kernel-10.0, runtime_tools-2.1, stdlib-6.0 + +# wx-2.5 + +## Improvements and New Features + +- Added support for compiling Erlang/OTP for Windows on ARM64. + + Own Id: OTP-19480 + Related Id(s): PR-8734 + +> #### Full runtime dependencies of wx-2.5 +> +> erts-12.0, kernel-8.0, stdlib-5.0 + +# Thanks to + +Aleksander Lisiecki, Anders Ågren Thuné, Andrea Leopardi, Ariel Otilibili, +Benedikt Reinartz, Brujo Benavides, Chris Freeze, Christophe De Troyer, Cocoa, +Dániel Szoboszlay, dependabotbot, Dmitri Vereshchagin, Douglas Vought, Egor +Ignatov, Frank Hunleth, Fredrik Frantzen, Frej Drejhammar, Hichem Fantar, iri, +Isabell H, Jan Uhlig, Jean-Sébastien Pédron, João Henrique Ferreira de Freitas, +Johannes Christ, Jonas Bernoulli, Jonatan Kłosko, José Valim, Juan Barrios, +Julian Doherty, Keyhan Jannat Khah ☕, Kirill A. Korinsky, lucioleKi, Lukasz +Samson, Maria Scott, Mario Idival, Mario Uher, Marko Mindek, Martin Davidsson, +Matwey V. Kornilov, Maxim Fedorov, Michael Davis, Michael Neumann, Nelson Vides, +Onno Vos, preciz, Richard Carlsson, Robin Morisset, Roeland van Batenburg, +sabiwara, siiky, Stavros Aronis, Steffen Deusch, Tobias Pfeiffer, Tomer, Vance +Shipley, William Fank Thomé, Wojtek Mach + |