Fix sequence matching.

src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -189,7 +189,8 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
 
   /** Is this argument node of the form <expr> : _* ?
    */
-  def isWildcardStarArg(tree: untpd.Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
+  def isWildcardStarArg(tree: Tree)(implicit ctx: Context): Boolean = unbind(tree) match {
+    case Typed(Ident(nme.WILDCARD_STAR), _) => true
     case Typed(_, Ident(tpnme.WILDCARD_STAR)) => true
     case Typed(_, tpt: TypeTree) => tpt.hasType && tpt.tpe.isRepeatedParam
     case _ => false

src/dotty/tools/dotc/ast/tpd.scala

@@ -76,8 +76,13 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def Block(stats: List[Tree], expr: Tree)(implicit ctx: Context): Block =
     ta.assignType(untpd.Block(stats, expr), stats, expr)
 
-  def maybeBlock(stats: List[Tree], expr: Tree)(implicit ctx: Context): Tree =
-    if (stats.isEmpty) expr else Block(stats, expr)
+  /** Join `stats` in front of `expr` creating a new block if necessary */
+  def seq(stats: List[Tree], expr: Tree)(implicit ctx: Context): Tree =
+    if (stats.isEmpty) expr
+    else expr match {
+      case Block(estats, eexpr) => cpy.Block(expr)(stats ::: estats, eexpr)
+      case _ => Block(stats, expr)
+    }
 
   def If(cond: Tree, thenp: Tree, elsep: Tree)(implicit ctx: Context): If =
     ta.assignType(untpd.If(cond, thenp, elsep), thenp, elsep)

src/dotty/tools/dotc/transform/ExplicitOuter.scala

@@ -136,7 +136,9 @@ object ExplicitOuter {
 
   /** A new outer accessor or param accessor */
   private def newOuterSym(owner: ClassSymbol, cls: ClassSymbol, name: TermName, flags: FlagSet)(implicit ctx: Context) = {
-    ctx.newSymbol(owner, name, Synthetic | flags, cls.owner.enclosingClass.typeRef, coord = cls.coord)
+    val target = cls.owner.enclosingClass.typeRef
+    val info = if (flags.is(Method)) ExprType(target) else target
+    ctx.newSymbol(owner, name, Synthetic | flags, info, coord = cls.coord)
   }
 
   /** A new param accessor for the outer field in class `cls` */
@@ -302,7 +304,7 @@ object ExplicitOuter {
         val outerAccessorCtx = ctx.withPhaseNoLater(ctx.lambdaLiftPhase) // lambdalift mangles local class names, which means we cannot reliably find outer acessors anymore
         ctx.log(i"outer to $toCls of $tree: ${tree.tpe}, looking for ${outerAccName(treeCls.asClass)(outerAccessorCtx)} in $treeCls")
         if (treeCls == toCls) tree
-        else loop(tree select outerAccessor(treeCls.asClass)(outerAccessorCtx))
+        else loop(tree.select(outerAccessor(treeCls.asClass)(outerAccessorCtx)).ensureApplied)
       }
       ctx.log(i"computing outerpath to $toCls from ${ctx.outersIterator.map(_.owner).toList}")
       loop(This(ctx.owner.enclosingClass.asClass))

src/dotty/tools/dotc/transform/LambdaLift.scala

@@ -384,14 +384,23 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisTransform
     private def addFreeParams(tree: Tree, proxies: List[Symbol])(implicit ctx: Context, info: TransformerInfo): Tree = proxies match {
       case Nil => tree
       case proxies =>
+        val sym = tree.symbol
         val ownProxies =
-          if (!tree.symbol.isConstructor) proxies
-          else proxies.map(_.copy(owner = tree.symbol, flags = Synthetic | Param))
+          if (!sym.isConstructor) proxies
+          else proxies.map(_.copy(owner = sym, flags = Synthetic | Param))
         val freeParamDefs = ownProxies.map(proxy =>
           transformFollowingDeep(ValDef(proxy.asTerm).withPos(tree.pos)).asInstanceOf[ValDef])
+        def proxyInit(field: Symbol, param: Symbol) =
+          transformFollowingDeep(ref(field).becomes(ref(param)))
+        def copyParams(rhs: Tree) = {
+          ctx.log(i"copy params ${proxies.map(_.showLocated)}%, %, own = ${ownProxies.map(_.showLocated)}%, %")
+          seq((proxies, ownProxies).zipped.map(proxyInit), rhs)
+        }
         tree match {
           case tree: DefDef =>
-            cpy.DefDef(tree)(vparamss = tree.vparamss.map(freeParamDefs ++ _))
+            cpy.DefDef(tree)(
+                vparamss = tree.vparamss.map(freeParamDefs ++ _),
+                rhs = if (sym.isPrimaryConstructor) copyParams(tree.rhs) else tree.rhs)
           case tree: Template =>
             cpy.Template(tree)(body = freeParamDefs ++ tree.body)
         }

src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -136,7 +136,7 @@ class PatternMatcher extends MiniPhaseTransform with DenotTransformer {thisTrans
         def callDirect   = tgt.select(nme.drop).appliedTo(Literal(Constant(n)))
         def callRuntime  = ref(defn.traversableDropMethod).appliedTo(tgt, Literal(Constant(n)))
 
-        def needsRuntime = tgt.tpe derivesFrom defn.SeqClass /*typeOfMemberNamedDrop(tgt.tpe) == NoType*/
+        def needsRuntime = !(tgt.tpe derivesFrom defn.SeqClass) /*typeOfMemberNamedDrop(tgt.tpe) == NoType*/
 
         if (needsRuntime) callRuntime else callDirect
       }

src/dotty/tools/dotc/typer/Typer.scala

@@ -377,10 +377,11 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     }
     tree.expr match {
       case id: untpd.Ident if (ctx.mode is Mode.Pattern) && isVarPattern(id) =>
-        if (id.name == nme.WILDCARD) regularTyped(isWildcard = true)
+        if (id.name == nme.WILDCARD || id.name == nme.WILDCARD_STAR) regularTyped(isWildcard = true)
         else {
           import untpd._
-          typed(Bind(id.name, Typed(Ident(nme.WILDCARD), tree.tpt)).withPos(id.pos), pt)
+          val name = if (untpd.isWildcardStarArg(tree)) nme.WILDCARD_STAR else nme.WILDCARD
+          typed(Bind(id.name, Typed(Ident(name), tree.tpt)).withPos(id.pos), pt)
         }
       case _ =>
         if (untpd.isWildcardStarArg(tree))

tests/run/i659.scala

@@ -0,0 +1,26 @@
+class Foo(val a: Int) {
+  def foo = { {case x => x + a}: PartialFunction[Int, Int]}
+  class Bar { def result(x: Int) = x + a }
+  def bar = new Bar
+}
+
+class VFoo(val a: Int) extends AnyVal {
+  def foo = { {case x => x + a}: PartialFunction[Int, Int]}
+}
+
+object Test extends dotty.runtime.LegacyApp {
+
+  def Foo(a: Int) = {
+    class Bar { def result(x: Int) = x + a }
+    new Bar().result(2)
+  }
+
+  val x1 = new Foo(1).bar.result(2)
+  assert(x1 == 3, s"x1 = $x1")
+  val x2 = Foo(1)
+  assert(x2 == 3, s"x2 = $x2")
+  val x3 = new Foo(1).foo.apply(2)
+  assert(x3 == 3, s"x3 = $x3")
+  val x4 = new VFoo(1).foo.apply(2)
+  assert(x4 == 3, s"x4 = $x4")
+}