Optimize matching of literals for single-valued types

If a type only has one clause and if the pattern is literal,
the matching can be done more efficiently by directly comparing
with the literal.

Example:

    find(String, "") -> String;
    find(String, <<>>) -> String;
    find(String, SearchPattern) ->
       .
       .
       .

Without this optimization, the relevant part of the code would look
this:

      {test,bs_start_match2,{f,3},2,[{x,1},0],{x,2}}.
      {test,bs_test_tail2,{f,4},[{x,2},0]}.
      return.
    {label,3}.
      {test,is_nil,{f,4},[{x,1}]}.
      return.
    {label,4}.
      .
      .
      .

That is, if {x,1} is a binary, a match context will be built to
test whether {x,1} is an empty binary.

With the optimization, the code will look this:

      {test,is_eq_exact,{f,3},[{x,1},{literal,<<>>}]}.
      return.
    {label,3}.
      {test,is_nil,{f,4},[{x,1}]}.
      return.
    {label,4}.
      .
      .
      .

0 files changed, 0 insertions, 0 deletions