handle AnnotatedTypes transparently

[olhotak]

Depends on #339 and #345.

Changes phases up to Erasure to handle AnnotatedTypes transparently like their underlying type.

In Erasure, all type annotations are removed (AnnotatedTypes are replaced with their underlying). Without this, the backend blows up in various ways when it encounters an AnnotatedType.

These changes are necessary and almost sufficient to make the current test suite pass if Typer.adapt is modified to attach an annotation to the type of every tree whose type isValueType.

The remaining tests that fail when all such types are annotated are:

• dotc_core due to dotc_core test fails when Config.cacheImplicitScopes == false #347
• lambdalift in pos_all due to a symbol with invalid period: a denot for module C in method foo2 has a period of SyntheticMethods, but denot is called on it from a context in FirstTransform.
• neg_i0091_infpaths loops due to an unboundedly growing TermRef (whose prefix is a shorter version of itself) that seems to only grow when it is wrapped in an AnnotatedType.

[olhotak]

I fixed a few more cases where AnnotatedTypes were not handled transparently. This fixes the neg_i0091_infpaths test.

[samuelgruetter]

This fixes the neg_i0091_infpaths test.

but that's by accident, I guess, because it changes the completion order. So it's not clear if the problem is really fixed, or just "not exposed any more by neg/i0091_infpaths".

[olhotak]

No, the neg_i0091_infpaths test was looping due to the missing stripAnnots in isInteresting. As a result, checkNonCyclic failed to detect a cycle and turn it into an error.

[samuelgruetter]

On what branch/commit was this the case? I've just tested tests/neg/i0091-infpaths.scala on master (1ab02ce) and on this PR (211fe56), and the cycle is detected in both.
Looks like this was already fixed in #279.

[olhotak]

i0091-infpaths is not a problem normally (it passes).

It was only a problem when types have annotations, because the AnnotatedTypes were not being handled transparently in many places (including isInteresting). This PR fixes most of the places where AnnotatedTypes were not being handled transparently, so that all of the test suite (except lambdalift in pos_all, currently) now passes even if you annotate the type of every tree whose type is a value type. (Annotating non-value types still breaks many things, but non-value types are less likely to be annotated.)

[samuelgruetter]

Ok, got it, so that commit message has to be understood as "neg_i0091_infpaths now also passes if Typer.adapt is modified to attach an annotation to the type of every tree whose type is a value type".

[olhotak]

Oh, right, I see why it is confusing.

I should probably squash the two commits into one, with only the commit message of the first one, with no mention of the specific test (since before the first commit, almost all of the tests fail if types have annotations). Would that make sense?

[samuelgruetter]

I think so :)

[olhotak]

I have squashed the two commits. Sorry for the confusion.

[olhotak]

I investigated the failure in lambdalift when types are annotated.

transformStats in FirstTransform calls reorderAndComplete with ctx.withPhase(thisTransformer.next)). I don't understand why the phase is changed.

reorderAndComplete creates the symbol for the module class and gives it its denotation, with a period in the next phase, SyntheticMethods.

Still in FirstTransform, the type assigner attempts to assign a type to a Block. This calls TypeAssigner.avoid, which eventually asks for the denotation of the symbol. The context is in phase FirstTransform but the symbol already has a later denotation, so this causes a crash.

Why does this not happen when types are not annotated? TypedTreeCopier.Block contains a test (expr.tpe eq tree.expr.tpe). If this is true, the type assigner is not used for that tree. When types are not annotated, this test always succeeds and the type assigner is never called (for this test). When types are annotated, expr.tpe and tree.expr.tpe have the same type but different annotations, so the test fails, the type assigner is called, and crashes.

[DarkDimius]

transformStats in FirstTransform calls reorderAndComplete with ctx.withPhase(thisTransformer.next)). I don't understand why the phase is changed.

Most phases actually transform the tree at ctx.withPhase(thisTransformer.next)), because that's the earliest phase when type(denot) transformations defined by phase have been applied.

Can you please tell me how to reproduce the particular error that you are seeing(and maybe share an error log). LambdaLift is very far away in the pipeline from FirstTransform so such failure is strange.

[olhotak]

The problem has nothing to do with the LambdaLift phase. It just occurs when compiling tests/pos/lambdalift.scala with Dotty, in the FirstTransform phase.

You can get my branch here: olhotak/dotty@b5e05fde5

Here is the output: https://gist.github.com/olhotak/67c4aca12a1b39814643