Fix partial functions with non trivial selector

E.g.
```
class Foo(val field: Option[Int])

val p: PartialFunction[Foo, Int] =
  foo => foo.field match { case Some(x) => x }
```

Author: allanrenucci

compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala

@@ -74,38 +74,38 @@ class ExpandSAMs extends MiniPhase {
         val isDefinedAtFn = overrideSym(defn.PartialFunction_isDefinedAt)
         val applyOrElseFn = overrideSym(defn.PartialFunction_applyOrElse)
 
+        def translateMatch(tree: Match, pfParam: Symbol, cases: List[CaseDef], defaultValue: Tree) = {
+          val selector = tree.selector
+          val selectorTpe = selector.tpe.widen
+          val defaultSym = ctx.newSymbol(pfParam.owner, nme.WILDCARD, Synthetic, selectorTpe)
+          val defaultCase =
+            CaseDef(
+              Bind(defaultSym, Underscore(selectorTpe)),
+              EmptyTree,
+              defaultValue)
+          val unchecked = Annotated(selector, New(ref(defn.UncheckedAnnotType)))
+          cpy.Match(tree)(unchecked, cases :+ defaultCase)
+            .subst(param.symbol :: Nil, pfParam :: Nil)
+              // Needed because  a partial function can be written as:
+              // param => param match { case "foo" if foo(param) => param }
+              // And we need to update all references to 'param'
+        }
+
         def isDefinedAtRhs(paramRefss: List[List[Tree]]) = {
           val tru = Literal(Constant(true))
           def translateCase(cdef: CaseDef) =
             cpy.CaseDef(cdef)(body = tru).changeOwner(anonSym, isDefinedAtFn)
           val paramRef = paramRefss.head.head
           val defaultValue = Literal(Constant(false))
-          translateMatch(pf, paramRef, pf.cases.map(translateCase), defaultValue)
+          translateMatch(pf, paramRef.symbol, pf.cases.map(translateCase), defaultValue)
         }
 
         def applyOrElseRhs(paramRefss: List[List[Tree]]) = {
           val List(paramRef, defaultRef) = paramRefss.head
           def translateCase(cdef: CaseDef) =
             cdef.changeOwner(anonSym, applyOrElseFn)
           val defaultValue = defaultRef.select(nme.apply).appliedTo(paramRef)
-          translateMatch(pf, paramRef, pf.cases.map(translateCase), defaultValue)
-        }
-
-        def translateMatch(tree: Match, selector: Tree, cases: List[CaseDef], defaultValue: Tree) = {
-          assert(tree.selector.symbol == param.symbol)
-          val selectorTpe = selector.tpe.widen
-          val defaultSym = ctx.newSymbol(selector.symbol.owner, nme.WILDCARD, Synthetic, selectorTpe)
-          val defaultCase =
-            CaseDef(
-              Bind(defaultSym, Underscore(selectorTpe)),
-              EmptyTree,
-              defaultValue)
-          val unchecked = Annotated(selector, New(ref(defn.UncheckedAnnotType)))
-          cpy.Match(tree)(unchecked, cases :+ defaultCase)
-            .subst(param.symbol :: Nil, selector.symbol :: Nil)
-              // Needed because  a partial function can be written as:
-              // param => param match { case "foo" if foo(param) => param }
-              // And we need to update all references to 'param'
+          translateMatch(pf, paramRef.symbol, pf.cases.map(translateCase), defaultValue)
         }
 
         val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)))

tests/run/partialFunctions.scala

@@ -1,10 +1,15 @@
 object Test {
 
-  def takesPartialFunction(a: PartialFunction[Int, Int]) = a(1) 
+  def takesPartialFunction(a: PartialFunction[Int, Int]) = a(1)
+  class Foo(val field: Option[Int])
 
   def main(args: Array[String]): Unit = {
-    val partialFunction: PartialFunction[Int, Int] = {case a: Int => a}
+    val p1: PartialFunction[Int, Int] = { case a: Int => a }
+    assert(takesPartialFunction(p1) == 1)
 
-    assert(takesPartialFunction(partialFunction) == 1)
+    val p2: PartialFunction[Foo, Int] =
+      foo => foo.field match { case Some(x) => x }
+    assert(p2.isDefinedAt(new Foo(Some(1))))
+    assert(!p2.isDefinedAt(new Foo(None)))
   }
 }