…more.

They are using primitives and opcodes that were extracted to objects.

…ces.

Saves allocations but breaks thread-safety of  BackendInterface.

ArrayClass is magical. Several methods had recursive implementation. PatternMatching was shadowing parameter.

Those methods ended having same implementation in dotty and scalac.
And even more they are implemented in terms of what is already part of exposed abstractions.
Providing default implementations, that can be overridden in backends if ever needed.

See comment here: https://issues.scala-lang.org/browse/SI-8989?focusedCommentId=71196&page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel#comment-71196
 for illustration.

Found by just looking at the code. Interestingly enough none of the tests broke.

By reusing same decorator instances.

…forming a test.

Also gather in one place Product1s

…on more lazy.

In Scalac any function call has Select as it function. In dotty it could be an Ident.
Eg in Scalac you get Select(Preded$, println);
while in dotty you get Ident(println)
In order to get actual receiver need to either look at the type(which is TermRef) or at owner chain.
First one is more systematic but is isn't exposed in the abstraction API, so using the second one.

TypeApply's are free to not have a Apply node around them in dotty.

… reused

…efDefs and scalac LabelDefs

DefDefs are assumed to be grouped in blocks that share same return address used to jump back.

Required to support arrays in dotty. Operations on those couldn't be decided based on symbol.

…to generate them for Scalac

Based on https://github.com/retronym/scala/compare/topic/invoke-dynamic-lambda adapted to abstract from global.

snapshot scala

…aring-backend

Handling Ident's in dotty requires analysing its type,
Instead of exporting a lot of abstractions around types
I'd better go with a single method that hides this.

This is a re-run of SI-5158 in two different contexts.

As reported, the result of `unapply[Seq]` under name based pattern
matching might not guarantee stability of results of calls to
`_1`, `apply(i)`, etc, so we call these eagerly, and call them
once only.

I also found a case in regular pattern matching that we hadn't
accounted for: extracting elements of sequences (either from
a case class or from an `unapplySeq`) may also be unstable.

This commit changes `ExtractorTreeMaker` to force storage
of such binders, even under `-optimize`. This parallels the change
to `ProductExtractorTreeMaker` in 8ebe8e3.

I have added a special case for traditional `unapply` methods
returning `Option`. This avoids a change for:

```
% cat test/files/run/t9003b.scala
object Single {
  def unapply(a: Any) = Some("")
}

object Test {
  def main(args: Array[String]): Unit = {
    "" match {
      case Single(x) =>
        (x, x)
    }
  }
}
% qscalac -optimize -Xprint:patmat test/files/run/t9003b.scala 2>&1 | grep --context=5 get
      case <synthetic> val x1: Any = "";
      case5(){
        <synthetic> val o7: Some[String] = Single.unapply(x1);
        if (o7.isEmpty.unary_!)
          matchEnd4({
            scala.Tuple2.apply[String, String](o7.get, o7.get);
            ()
          })
        else
          case6()
      };
% scalac-hash v2.11.4 -optimize -Xprint:patmat test/files/run/t9003b.scala 2>&1 | grep --context=5 get
      case <synthetic> val x1: Any = "";
      case5(){
        <synthetic> val o7: Some[String] = Single.unapply(x1);
        if (o7.isEmpty.unary_!)
          matchEnd4({
            scala.Tuple2.apply[String, String](o7.get, o7.get);
            ()
          })
        else
          case6()
      };
```

needed to handle array_clone in dotty. Which doesn't have a symbol but isn't byte code primitive operation

…aring-backend