The macro wraps the (untransformed) expression in the skeleton of the
state machine class. Compiler phases between this point and the late
async transform will correctly add outer pointers, lift captured vars
into Ref objects etc. The state machine class itself will also undergo
any transforms that it needs, such as specialization.

The macro is wired up using the FastTrack facility in line with other
macros that are quasi-intrinsic (ie, implemented in the scala-compiler.jar).

After post-erasure, we run the ANF and state machine transform.

The old code used the macro refletion API -- these usages are
now being replaced with direct use of the richer Global API.

Passes the correct owner symbol to `useFields` to fix a bug
with local modules.

Refactors to store state about the current async block in a var
which allows us to mix in all the implementation once into
AsyncPhase.

Remove some testing FutureSystems. We'll refactor the tests
to use ScalaConcurrentFutureSystem.

Allow a custom front end to supply an alternative FutureSystem
attached to the block defining the state machine wrapper class.
Demonstrate this with a test case for an annotation driven
front end that targets an alternative Future implementation.

Remove some now-unused customization points from FutureSystem.
For example, we don't need to abstract over the choice of
base class for the state machine as a custom front end now
creates the state machine tree directly.

FutureSystem now deals directly in Trees, rather than in
`c.Expr`. I've kept a light weight option (a type alias
`type Expr[T] = Tree`) so we can have a little compiler support
for getting the types right and documentation for
`FutureSystem` implementors.

Refactor the ANF transform (and others) to directly be a
TypingTransformer.

Remove the need to subclass Function0 in the state machine
by kicking things off with `Future.unit.onComplete(stateMachine)`.
This reduces bloat in the generated code due to Function0
specialization.

I've also elminated the macro application in the early transform
in favour of wrapping the argument in `Block(<arg> :: Nil, q"()"}`.
This ran into some "pure expression has no effect" warnings which
I've suppressed with a new tree annotation.

Most of the `auto_` test cases are converted to use the
standard scala.concurrent version of async. Now that the
transform is always happening post-erasure, there is no need to
keep those tests under the annotation driven async test (which
used to be the only way to get post-typer expansion).

A few test can only be expressed with the annotation driven
version of async, namely those that have an async boundary
in an extractor. These have been moved into the
`AnnotationDrivenAsyncTest`.

  - most regular scala.async.Async tests pass
  - AsyncId converted to ScalaConcurrentAsync
  - non-standard tests not properly integrated yet
  - actual test failure in `run/futures.scala`
  - neg/NakedAwait still missing (alternative first)
  - remove late.scala (converted to AnnotationDrivenAsync)
  - Remove uncheckedBounds.scala (the problem no longer exists post-erasure)

Also:
  - remove late.scala (converted to AnnotationDrivenAsync)
  - Remove uncheckedBounds.scala (the problem no longer exists post-erasure)

UseFields needs to do what explicit outer would have done:
access inner classes must access fields via the outer
parameter and we must ensure fields accessed from inners
are not JVM private.

This code path was only relevant when async was run as a macro
in the presentation compiler.

As a late-running ANF transform must do.

Deal with the representation of local modules at async's
new place in the compiler pipeline.

Use more efficient/idiomatic collection of local def trees.
(`Tree#children` creates temporary lists.)

A long overdue overhaul.

Originally, we defined this in terms of a pair of mutually recursive
transforms (`anf` and `linearize`). We can simplfy the implementation
by collapsing these the cases of single Transformer.

This transformer is designed for "thicket" based transforms, where
a single input tree can map to a list of output trees which will
be flattened into the enclosing `Block`. An enclosing block will be
automatically added if there was none before.

Make the transform more idiomatic by more widespread use of
utilities to generated attributed trees rather than passing
untyped trees through `localTyper.typed`.

Rework special casing of Unit/Nothing typed expressions to
avoid temporary vals of these types to avoid littering the
resulting trees with `BoxedUnit` references.

Avoid unnecessary temporaries in:
  - the suffix of the args of an Apply the follows the final `await`
  - the result of If that only awaits the condition
  - similarly, the result of a Match that only awaits the scrutinee
  - "safe to inline" expressions like simple Idents or constants.

Remove special cases for derived value classes which are
eliminated now before the ANF transform.

Furthermore:

  - Deal with ArrayValue tree
  - Remove cast which was used ot suppress typer warning
  - Don't need to deal with nested Applys after uncurry
  - Remove an new-unneeded adjustment from the entry point to the ANF
    and from MatchResultTransformer.

Transform the ClassDef and DefDef in separate cases.
This reduces some of manual atOwner and treeCopy busywork.

TypingTransformers can easily feed null trees into here
if they don't assign `curTree`.

The ANF transform trace is demoted to the
"edit a boolean and re-compile" UI.

Also, lifted lazy var fields need not be MUTABLE.

Deal with the underlying Set directly rather than
using the ClassTag indexed lookup/removal.

We used to lift the control flow for any pattern match or
if/else into fine grained states if it enclosed even a single
await call.

Instead, we now keep as much of the control flow as possible
in the current state. The program point after the control flow
statement is lifted into a new state iff it is reachable from
any branch that contains an await.

LabelDef-s representing cases and the matchEnd of patterns are now
only lifted into states if they are the target of a label jump
from a resumption handler.

To make this analysis possible, we form a context chain of
AsyncBlockBuilders to let the translation of the label jumps compare
the current state to that current state of the enclosing block builder
that holds the LabelDefs. If these differ, we can conclude that we
have crossed an async boundary and mark the LabelDef for lifting
into state.

Here's how the simplification helps:

https://gist.github.com/retronym/50839a051db9b6d1fcd0719d99ecbfc2

Refactorings along the way:

  - introduce a ThicketTransformer to transform `Tree => List[Tree]`
  - make `symLookup` more convenient to access
  - add some internal flags to disable state compaction and field
    nulling which help to debug the phase
  - unify onto a single `AsyncState` class. Different use cases
    are served by eagerly adding additional logic, rather than
    having this added later on in the variants of
    `mkCompletionHandler`
  - detect and remove empty states in `compactStates`. It seems easier
    now to do this than to avoid constructing them.
  - Try a bit harder to avoid redundant `()` in stats.
  - Move synthesis of async block generation into
    StateBuilder.build (formrly known as resultSimple). This is
    now the only factory method on StateBuilder.
  - Fix propagation of the enclosing subsequent state into
    nested expression positions
  - In combination, this lets us perform async block completion
    inline in all terminal states, there is no need to write the
    result to lifted field and make a state transition.
  - Remove the `currTree` var in favour of delegating to
    the field in the `stateBuilder` var
  - Encapsulate state transition bookkeeping

While looking more closely at the implementation, I
realised our approach of nulling dead variables at the
start of the subsequent state was wrong, we retained
the references for longer than needed.

I've moved the nulling into the conclusion of the
state of last usages.

Remove the warnings test which isn't relevant with post-typer ANF.

We don't have any phase-dependent logic left.

This saves allocations for root imports etc.

Also:
 - remove some redundant or simply unused parameters.
 - tighten access on some members

If no methods have been marked for tranform, disable
the phase for the entire unit.

And reuse existing utility method to change module class owner.

The input trees are always typed now which means the early cases
subsume the ones being deleted here.

  - The state machine generated by the front end macro must Now
    implement a small set of methods as a facade over the
    particular Future/Awaitable/Task type being used. This
    replaces the AST factory methods in `FutureSystem`
  - Remove intrinsic implemnentation for scala-async's async
    macro. Show what it will need to do in a test implementation,
    `s.t.n.partest.Async` and update all test cases to use this.
  - Add a heuristic to interpret `@compileTimeOnly` annotated
    methods to register `await` methods. Defer the check in refchecks
    for all of these and instead check that no references survive
    the async phase.
  - Refactor the test implementations of async front ends to
    share an interface for the state machine. We don't ship
    this but it could be copy/pasted into third party integrations.
  - Add a test integration with Java's CompletableFuture.
  - Expose a method through macro `Internals` API to let
    front ends mark a method in the state machine for async
    translation.

This lets us use IntelliJ's code coverage analysis.

 - Adapt detection logic to the post-erasure tree shapes
 - Lift restriction about || and && in favour of a
   rewrite to `If` in the ANF transform
 - import relevant parts of the test from scala-async.

It seems generally useful enough to move it out of
the async utilities. I've also added a unit test.

scala/scala-async#210

scala/scala-async#206

Show source file context for reported compiler
errors and warnings, as we would expect from
the normal ConsoleReporter.

Rather than assuming its a var.

 - No longer add the `$async` suffix to fresh names. Add a test to
   show that we no longer risk clashing with lambda lifted names
   because we're coordinating through the unit's FreshNameCreator.
 - Add a facility to FreshNameCreator to support clients that
   want to generate many fresh names from a single prefix
   and avoid the overhead of going through `newTermName`
   when subsequent units also want to generate `x$0`, etc.
 - Add a little efficiency to name concatenation by use of
   presized of string builders.

Some will be made Scala.js compatible in a subsequent commit and
moved back to run.

 - Remove '_' and line number from state machine classs names.
 - Rename `state$async` to `state`.

Wrap the async expression in `locally { ... }` to
force value class boxing. This seems to work better
than `{ ... }: Any`, which ends up with `Function`
trees typed with `Any` which violoates an assumption
in `delambdafy`.

We can defer the check until the current location of the "fallback"
check without sacrificing the specific error messages.