Fix crash in the compiler when compiling element(2, not_a_tuple)
Test setelement(1, not_a_tuple, NewValue)
compiler: Use the literal pool for floating point constants

The BEAM loader will put floating point constants into the
literal pools for the module, but it will not check for duplicates.
We can do much better by having the compiler use the literal
pool for floating point constants.
beam_type: Convert integer to float at compile time

In code such as:

   X / 2

the following code would be output from beam_type for the division:

    {fconv,{x,0},{fr,0}}.
    {fconv,{integer,2},{fr,1}}.
    fclearerror.
    {bif,fdiv,{f,0},[{fr,0},{fr,1}],{fr,0}}.

That is, the integer 2 would be converted to the float 2.0 at
run-time by "{fconv,{integer,2},{fr,1}}". Make sure that we do
the conversion at compile time.

Noticed-by: Richard O'Keefe
Forbid multiple values in Core Erlang sequence arguments

It does not make sense to return multiple values from a sequence
argument and the Kernel Erlang passes can't cope with it.

The linting pass now knows how to detect this kind of defunct code and
the Core code folding pass is changed to not generate code like that
when optimizing away multiple-valued lets in effect mode.

Reported-by: José Valim
Merge branch 'bjorn/compiler/crash/OTP-10794'

* bjorn/compiler/crash/OTP-10794:
  Test setelement(1, not_a_tuple, NewValue)
  Fix crash in the compiler when compiling element(2, not_a_tuple)
Add two tests for unused multiple values in effect context
beam_validator: Eliminate dialyzer warnings for unmatched returns

The assert_fls/2 and assert_type/3 functions both return the
Vst passed to them, but all callers ignore the return value.
Given the name of the functions, they are not expected to return
anything. Make it so by changing the return value to 'ok'.

There are two calls to bsm_get_context/2 used only to validate
that the match context is valid. Call bsm_validate_context/2
instead.

In bsm_validate_context/2, explicitly match the return value of
bsm_get_context/2 to '_' to make it clear that it is not used.
beam_receive: Eliminate dialyzer warning for unmatched return
compile: Eliminate warnings for unmatched return values
Merge branch 'nox/fix-seq-opt/OTP-10818'

* nox/fix-seq-opt/OTP-10818:
  Add two tests for unused multiple values in effect context
  Forbid multiple values in Core Erlang sequence arguments
Merge branch 'bjorn/compiler/dialyzer-warnings'

* bjorn/compiler/dialyzer-warnings:
  compile: Eliminate warnings for unmatched return values
  beam_receive: Eliminate dialyzer warning for unmatched return
  beam_validator: Eliminate dialyzer warnings for unmatched returns
Fix unsafe optimization of funs

Commits 53bd4974a101 and 726f6e4c7afe simplified the handling of
match_fail (used to generated exceptions such as 'function_clause')
by first rewriting them to a call to erlang/error{1,2} and later
rewriting them to specialized BEAM instructions (to reduce the
code size).

There was one flaw, though, which only was exposed when more
aggressive optimizations were added in c3b60f86c622. Here is an
example to explain it:

t(V) ->
    fun(get) -> V end.

The following BEAM code will be initially generated for the fun:

{function, '-t/1-fun-0-', 2, 5}.
  {label,1}.
    {line,[{location,"t.erl",5}]}.
    {func_info,{atom,t},{atom,'-t/1-fun-0-'},2}.
  {label,2}.
    {test,is_eq_exact,{f,2},[{x,0},{atom,get}]}.
    {move,{x,1},{x,0}}.
    return.
  {label,2}.
    {test_heap,2,1}.
    {put_list,{x,0},nil,{x,1}}.
    {move,{atom,function_clause},{x,0}}.
    {line,[{location,"t.erl",5}]}.
    {call_ext_only,2,{extfunc,erlang,error,2}}.

Translating back to Erlang code, that would be roughly:

'-t/1-fun-0-'(get, V) -> V;
'-t/1-fun-0-'(Arg1, _) -> erlang:error(function_clause, [Arg1]).

Note that the second argument (the free variable V) is not included
in the call to erlang:error/2.

The beam_except pass will simplify the code to:

{function, '-t/1-fun-0-', 2, 8}.
  {label,1}.
    {line,[{location,"t.erl",5}]}.
    {func_info,{atom,t},{atom,'-t/1-fun-0-'},2}.
  {label,2}.
    {test,is_eq_exact,{f,1},[{x,0},{atom,get}]}.
    {move,{x,1},{x,0}}.
    return.

The code has been shortened by jumping to the func_info/3 instruction.
Translating back to Erlang:

'-t/1-fun-0-'(get, V) -> V;
'-t/1-fun-0-'(Arg1, Arg2) -> erlang:error(function_clause, [Arg1,Arg2]).

it is clear that both arguments are now included in the
'function_clause' exception, even though the initially generated
code only included the first argument.

That is no problem in this particular case, but for some more complex
funs, optimizing the first version based on variable usage could make
the second version unsafe.

I rejected the following potential solutions:

- Including the free arguments in the call to erlang:error/2:

'-t/1-fun-0-'(get, V) -> V;
'-t/1-fun-0-'(Arg1, Arg2) -> erlang:error(function_clause, [Arg1,Arg2]).

Unfortunately, that is tricky. The free variables are only known
after the second pass in v3_kernel when variable usage has been
calculated. We would need to add a third pass (only for funs) that
would the free arguments to the second argument for erlang:error/2
*and* update the variable usage information.

- Calling beam_except earlier, from within beam_block before any
  optimizations based on variable usages are done.  But means that the
  problem could reappear in some other form in the future when other
  updates are done to the code generator and/or optimization passes.

The solution I have chosen is to modify beam_except to only replace
a call to erlang:error(function_class, Args) if the length of Args
is the same as the arity in the func_info/3 instruction. The code
will be slightly larger. Also, the free variables for funs and list
comprehensions will no longer be included in the function_clause
exception (that could be less confusing, but it also means less
information during debugging).
Add new binary conversion bifs

Added: binary_to_integer/1,2, integer_to_binary/1,2
Add float_to_binary and binary_to_float
Update copyright years
Prepare release