Track Function's SAM symbol & target type using an attachment

We cannot use the expected type to track whether a Function node
targets a SAM type, as the expected type may be erased (see test
for an example).

Thus, the type checker attaches a SAMFunction attachment to a
Function node when SAM conversion is performed in adapt. Ideally,
we'd move to Dotty's Closure AST, but that will need a
deprecation cycle.

Thanks to Jason for catching my mistake, suggesting the fix and
providing the test.

Both the sam method symbol and sam target type must be tracked,
as their relationship can be complicated (due to inheritance).

For example, the sam method could be defined in a superclass (T)
of the Function's target type (U).

```
trait T { def foo(a: Any): Any }
trait U extends T { def apply = ??? }

(((x: Any) => x) : U).foo("")
```

This removes some of the duplication in deriving the sam method
from the expected type, but some grossness (see TODO) remains.

1 files changed, 2 insertions, 1 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index cd5759f40f..a9d5b69e2e 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -1076,7 +1076,8 @@ trait Typers extends Adaptations with Tags with TypersTracking with PatternTyper
           val sam = samMatchingFunction(tree, pt) // this implies tree.isInstanceOf[Function]
           if (sam.exists && !tree.tpe.isErroneous) {
             val samTree = adaptToSAM(sam, tree.asInstanceOf[Function], pt, mode)
-            if (samTree ne EmptyTree) return samTree
+            if (samTree ne EmptyTree)
+              return samTree.updateAttachment(SAMFunction(pt, sam))
           }
         }