From 9ea42b02f07136ffd4bd8954cb619a3b3a791278 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Wed, 29 Apr 2015 21:27:55 +0200
Subject: [PATCH 01/13] Fix to error reporting of compiled units

---
 src/dotty/tools/dotc/Run.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/Run.scala b/src/dotty/tools/dotc/Run.scala
index c99f5efb9167..151288d23709 100644
--- a/src/dotty/tools/dotc/Run.scala
+++ b/src/dotty/tools/dotc/Run.scala
@@ -33,7 +33,7 @@ class Run(comp: Compiler)(implicit ctx: Context) {
     compileSources(sources)
   } catch {
     case NonFatal(ex) =>
-      println(s"exception occurred while compiling $units%, %")
+      println(i"exception occurred while compiling $units%, %")
       throw ex
   }
 

From 0da6780f503c85064f7228b8f3866a0defe88221 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Wed, 29 Apr 2015 21:34:01 +0200
Subject: [PATCH 02/13] New symbol creation method: `newNormalizedClassSymbol`.

It's common that one wants to create class symbols with arbitary parent types,
not just TypeRefs. But for the casual user it's non-obvious how to do it.
Hence the new creation method.
---
 src/dotty/tools/dotc/core/Symbols.scala | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/src/dotty/tools/dotc/core/Symbols.scala b/src/dotty/tools/dotc/core/Symbols.scala
index 2b91efbcd83c..94ac258daf6e 100644
--- a/src/dotty/tools/dotc/core/Symbols.scala
+++ b/src/dotty/tools/dotc/core/Symbols.scala
@@ -109,6 +109,30 @@ trait Symbols { this: Context =>
         ClassInfo(owner.thisType, _, parents, decls, selfInfo),
         privateWithin, coord, assocFile)
 
+  /** Same as `newCompleteClassSymbol` except that `parents` can be a list of arbitary
+   *  types which get normalized into type refs and parameter bindings.
+   */
+  def newNormalizedClassSymbol(
+      owner: Symbol,
+      name: TypeName,
+      flags: FlagSet,
+      parentTypes: List[Type],
+      decls: Scope = newScope,
+      selfInfo: Type = NoType,
+      privateWithin: Symbol = NoSymbol,
+      coord: Coord = NoCoord,
+      assocFile: AbstractFile = null): ClassSymbol = {
+    def completer = new LazyType {
+      def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
+        val cls = denot.asClass.classSymbol
+        val decls = newScope
+        val parentRefs: List[TypeRef] = normalizeToClassRefs(parentTypes, cls, decls)
+        denot.info = ClassInfo(owner.thisType, cls, parentRefs, decls)
+      }
+    }
+    newClassSymbol(owner, name, flags, completer, privateWithin, coord, assocFile)
+  }
+
   /** Create a module symbol with associated module class
    *  from its non-info fields and a function producing the info
    *  of the module class (this info may be lazy).

From a5eb07633581962289bf6ee32c2cc7de00333cf6 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Wed, 29 Apr 2015 21:37:32 +0200
Subject: [PATCH 03/13] Make tpd.ClassDef work for polymorphic parent classes.

The handling of the first parent of ClassDef was broken if
that parent had type parameters. This was exposed by following
commites which use ClassDef more intensively than before in
creating anonymous classes representing closures.
---
 src/dotty/tools/dotc/ast/tpd.scala | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index de0ef3344e4e..23b964dc4a0c 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -210,7 +210,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ta.assignType(untpd.TypeDef(sym.name, TypeTree(sym.info)), sym)
 
   def ClassDef(cls: ClassSymbol, constr: DefDef, body: List[Tree], superArgs: List[Tree] = Nil)(implicit ctx: Context): TypeDef = {
-    val firstParent :: otherParents = cls.info.parents
+    val firstParentRef :: otherParentRefs = cls.info.parents
+    val firstParent = cls.typeRef.baseTypeWithArgs(firstParentRef.symbol)
     val superRef =
       if (cls is Trait) TypeTree(firstParent)
       else {
@@ -225,7 +226,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         val constr = firstParent.decl(nme.CONSTRUCTOR).suchThat(constr => isApplicable(constr.info))
         New(firstParent, constr.symbol.asTerm, superArgs)
       }
-    val parents = superRef :: otherParents.map(TypeTree(_))
+    val parents = superRef :: otherParentRefs.map(TypeTree(_))
 
     val selfType =
       if (cls.classInfo.selfInfo ne NoType) ValDef(ctx.newSelfSym(cls))

From 959a112c6278ef06e501f117fbc3aba50f280eb7 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Wed, 29 Apr 2015 21:38:44 +0200
Subject: [PATCH 04/13] New utility method tpd.AnonymousClass

As the name implies, this creates an anonymous class.
---
 src/dotty/tools/dotc/ast/tpd.scala | 29 ++++++++++++++++++++++++++++-
 1 file changed, 28 insertions(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 23b964dc4a0c..4df3f7a63c38 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -245,6 +245,34 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ta.assignType(untpd.TypeDef(cls.name, impl), cls)
   }
 
+  /** An anonymous class
+   *
+   *      new parent { forwarders }
+   *
+   *  where `forwarders` contains forwarders for all functions in `fns`.
+   *  `fns` must be non-empty. The class has the same owner as the first function in `fns`.
+   *  Its position is the union of all functions in `fns`.
+   */
+  def AnonClass(parent: Type, fns: List[TermSymbol], methNames: List[TermName])(implicit ctx: Context): Block = {
+    def methName(fnName: TermName): TermName = if (fnName == nme.ANON_FUN) nme.apply else fnName
+    val owner = fns.head.owner
+    val parents =
+      if (parent.classSymbol.is(Trait)) defn.ObjectClass.typeRef :: parent :: Nil
+      else parent :: Nil
+    val cls = ctx.newNormalizedClassSymbol(owner, tpnme.ANON_FUN, Synthetic, parents,
+        coord = fns.map(_.pos).reduceLeft(_ union _))
+    println(i"creating anon class with parent $parent -> ${cls.info.parents}%, %")
+    println(cls.classInfo.classParents)
+    val constr = ctx.newConstructor(cls, Synthetic, Nil, Nil).entered
+    def forwarder(fn: TermSymbol, name: TermName) = {
+      val fwdMeth = fn.copy(cls, name, Synthetic | Method).entered.asTerm
+      DefDef(fwdMeth, prefss => ref(fn).appliedToArgss(prefss))
+    }
+    val forwarders = (fns, methNames).zipped.map(forwarder)
+    val cdef = ClassDef(cls, DefDef(constr), forwarders)
+    Block(cdef :: Nil, New(cls.typeRef, Nil))
+  }
+
   // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() }
   def WhileDo(owner: Symbol, cond: Tree, body: List[Tree])(implicit ctx: Context): Tree = {
     val sym = ctx.newSymbol(owner, nme.WHILE_PREFIX, Flags.Label | Flags.Synthetic,
@@ -255,7 +283,6 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     Block(List(DefDef(sym, rhs)), call)
   }
 
-
   def Import(expr: Tree, selectors: List[untpd.Tree])(implicit ctx: Context): Import =
     ta.assignType(untpd.Import(expr, selectors), ctx.newImportSymbol(ctx.owner, expr))
 

From e2c23bd56ef739682699384cf1956b62b75c1ae0 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 30 Apr 2015 09:32:14 +0200
Subject: [PATCH 05/13] Avoid prepare actions form earlier phases when doing a
 transformFollowinfDeep

See comment in the code.
---
 src/dotty/tools/dotc/transform/TreeTransform.scala | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/TreeTransform.scala b/src/dotty/tools/dotc/transform/TreeTransform.scala
index 3bd005991df7..0aba1e21394f 100644
--- a/src/dotty/tools/dotc/transform/TreeTransform.scala
+++ b/src/dotty/tools/dotc/transform/TreeTransform.scala
@@ -486,7 +486,14 @@ object TreeTransforms {
       var nxCopied = false
       var result = info.transformers
       var resultNX = info.nx
-      var i = mutationPlan(0) // if TreeTransform.transform() method didn't exist we could have used mutationPlan(cur)
+      var i = mutationPlan(cur)
+        // @DarkDimius You commented on the previous version
+        //
+        //     var i = mutationPlan(0) // if TreeTransform.transform() method didn't exist we could have used mutationPlan(cur)
+        //
+        // But we need to use `cur` or otherwise we call prepare actions preceding the
+        // phase that issued a transformFollowing. This can lead to "denotation not defined
+        // here" errors. Note that tests still pass with the current modified code.
       val l = result.length
       var allDone = i < l
       while (i < l) {

From 5cd90e5afd73c6f8354d0d3687fb2ee3a9f413e7 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 30 Apr 2015 09:34:19 +0200
Subject: [PATCH 06/13] New miniphase: ExpandSAMs

The phase replaces SAM closures with anonymous classes when necessary.
---
 src/dotty/tools/dotc/Compiler.scala           |  1 +
 src/dotty/tools/dotc/core/StdNames.scala      |  1 +
 src/dotty/tools/dotc/core/Types.scala         | 10 ++
 .../tools/dotc/transform/ExpandSAMs.scala     | 91 +++++++++++++++++++
 test/dotc/tests.scala                         |  3 -
 tests/neg/sammy_poly.scala                    |  7 --
 tests/pos/sams.scala                          | 63 +++++++++++++
 7 files changed, 166 insertions(+), 10 deletions(-)
 create mode 100644 src/dotty/tools/dotc/transform/ExpandSAMs.scala
 delete mode 100644 tests/neg/sammy_poly.scala
 create mode 100644 tests/pos/sams.scala

diff --git a/src/dotty/tools/dotc/Compiler.scala b/src/dotty/tools/dotc/Compiler.scala
index 44e7ac450e96..a9aa65201841 100644
--- a/src/dotty/tools/dotc/Compiler.scala
+++ b/src/dotty/tools/dotc/Compiler.scala
@@ -45,6 +45,7 @@ class Compiler {
            new ElimRepeated,
            new NormalizeFlags,
            new ExtensionMethods,
+           new ExpandSAMs,
            new TailRec),
       List(new PatternMatcher,
            new ExplicitOuter,
diff --git a/src/dotty/tools/dotc/core/StdNames.scala b/src/dotty/tools/dotc/core/StdNames.scala
index 74a121b47124..826cbe2c696b 100644
--- a/src/dotty/tools/dotc/core/StdNames.scala
+++ b/src/dotty/tools/dotc/core/StdNames.scala
@@ -418,6 +418,7 @@ object StdNames {
     val isArray: N              = "isArray"
     val isDefined: N            = "isDefined"
     val isDefinedAt: N          = "isDefinedAt"
+    val isDefinedAtImpl: N      = "$isDefinedAt"
     val isEmpty: N              = "isEmpty"
     val isInstanceOf_ : N       = "isInstanceOf"
     val java: N                 = "java"
diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala
index 595732b377ff..80cceed3857f 100644
--- a/src/dotty/tools/dotc/core/Types.scala
+++ b/src/dotty/tools/dotc/core/Types.scala
@@ -545,6 +545,11 @@ object Types {
         (name, buf) => buf ++= member(name).altsWith(x => x.isClass))
     }
 
+    final def fields(implicit ctx: Context): Seq[SingleDenotation] = track("fields") {
+      memberDenots(fieldFilter,
+        (name, buf) => buf ++= member(name).altsWith(x => !x.is(Method)))
+    }
+
     /** The set of members  of this type  having at least one of `requiredFlags` but none of  `excludedFlags` set */
     final def membersBasedOnFlags(requiredFlags: FlagSet, excludedFlags: FlagSet)(implicit ctx: Context): Seq[SingleDenotation] = track("implicitMembers") {
       memberDenots(takeAllFilter,
@@ -3049,6 +3054,11 @@ object Types {
     def apply(pre: Type, name: Name)(implicit ctx: Context): Boolean = name.isTypeName
   }
 
+  object fieldFilter extends NameFilter {
+    def apply(pre: Type, name: Name)(implicit ctx: Context): Boolean =
+      name.isTermName && (pre member name).hasAltWith(!_.symbol.is(Method))
+  }
+
   object takeAllFilter extends NameFilter {
     def apply(pre: Type, name: Name)(implicit ctx: Context): Boolean = true
   }
diff --git a/src/dotty/tools/dotc/transform/ExpandSAMs.scala b/src/dotty/tools/dotc/transform/ExpandSAMs.scala
new file mode 100644
index 000000000000..1340a206728d
--- /dev/null
+++ b/src/dotty/tools/dotc/transform/ExpandSAMs.scala
@@ -0,0 +1,91 @@
+package dotty.tools.dotc
+package transform
+
+import core._
+import Contexts._, Symbols._, Types._, Flags._, Decorators._, StdNames._, Constants._
+import SymDenotations.SymDenotation
+import TreeTransforms._
+import ast.untpd
+import ast.Trees._
+
+/** Expand SAM closures that cannot be represented by the JVM to anonymous classes.
+ *  These fall into three categories
+ *
+ *   1. Partial function closures, we need to generate a isDefinedAt method for these.
+ *   2. Closures implementaing non-trait classes.
+ *   3. Closures that get synthesized abstract methods in the transformation pipeline. These methods can be
+ *      (1) superaccessors, (2) outer references, (3) accessors for fields.
+ */
+class ExpandSAMs extends MiniPhaseTransform { thisTransformer =>
+  override def phaseName = "expandSAMs"
+
+  import ast.tpd._
+
+  def noJvmSam(cls: ClassSymbol)(implicit ctx: Context): Boolean =
+    !cls.is(Trait) || ExplicitOuter.needsOuterIfReferenced(cls) || cls.typeRef.fields.nonEmpty
+
+  override def transformBlock(tree: Block)(implicit ctx: Context, info: TransformerInfo): Tree = tree match {
+    case Block(stats @ (fn: DefDef) :: Nil, Closure(_, fnRef, tpt)) if fnRef.symbol == fn.symbol =>
+      tpt.tpe match {
+        case NoType => tree // it's a plain function
+        case tpe @ SAMType(_) if !noJvmSam(tpe.classSymbol.asClass) =>
+          if (tpe isRef defn.PartialFunctionClass) toPartialFunction(tree)
+          else tree
+        case tpe =>
+          cpy.Block(tree)(stats,
+              AnonClass(tpe, fn.symbol.asTerm :: Nil, nme.apply :: Nil))
+      }
+    case _ =>
+      tree
+  }
+
+  private def toPartialFunction(tree: Block)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    val Block(
+          (applyDef @ DefDef(nme.ANON_FUN, Nil, List(params), _, _)) :: Nil,
+          Closure(_, _, tpt)) = tree
+    val List(param) = params
+    // Dotty problem: If we match instead List(List(param)) directly,
+    // we get:
+    // Exception in thread "main" java.lang.AssertionError: assertion failed: self instantiation of (A?
+    // ...
+    //  at scala.Predef$.assert(Predef.scala:165)
+    //  at dotty.tools.dotc.core.Types$TypeVar.instantiateWith(Types.scala:2308)
+    //  at dotty.tools.dotc.core.Types$TypeVar.instantiate(Types.scala:2363)
+    //  at dotty.tools.dotc.typer.Inferencing$$anonfun$interpolate$1$1$$anonfun$apply$mcV$sp$4.apply(Inferencing.scala:198)
+    // at dotty.tools.dotc.typer.Inferencing$$anonfun$interpolate$1$1$$anonfun$apply$mcV$sp$4.apply(Inferencing.scala:195)
+    //
+    // I think it has to do with the double :: (or List) pattern to extract `param`.
+
+    val applyRhs: Tree = applyDef.rhs
+    val applyFn = applyDef.symbol.asTerm
+
+    val MethodType(paramNames, paramTypes) = applyFn.info
+    val isDefinedAtFn = applyFn.copy(
+        name  = nme.isDefinedAtImpl,
+        flags = Synthetic | Method,
+        info = MethodType(paramNames, paramTypes, defn.BooleanType)).asTerm
+    val tru = Literal(Constant(true))
+    def isDefinedAtRhs(paramRefss: List[List[Tree]]) = applyRhs match {
+      case Match(selector, cases) =>
+        assert(selector.symbol == param.symbol)
+        val paramRef = paramRefss.head.head
+        // Again, the alternative
+        //     val List(List(paramRef)) = paramRefs
+        // fails with a similar self instantiation error
+        def translateCase(cdef: CaseDef): CaseDef =
+          cpy.CaseDef(cdef)(body = tru).changeOwner(applyFn, isDefinedAtFn)
+        val defaultSym = ctx.newSymbol(isDefinedAtFn, nme.WILDCARD, Synthetic, selector.tpe.widen)
+        val defaultCase =
+          CaseDef(
+            Bind(defaultSym, untpd.Ident(nme.WILDCARD).withType(selector.tpe.widen)),
+            EmptyTree,
+            Literal(Constant(false)))
+        cpy.Match(applyRhs)(paramRef, cases.map(translateCase) :+ defaultCase)
+      case _ =>
+        tru
+    }
+    val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)))
+    val anonCls = AnonClass(tpt.tpe, List(applyFn, isDefinedAtFn), List(nme.apply, nme.isDefinedAt))
+    cpy.Block(tree)(List(applyDef, isDefinedAtDef), anonCls)
+  }
+}
diff --git a/test/dotc/tests.scala b/test/dotc/tests.scala
index 7761589ad24a..0e86303a2c2a 100644
--- a/test/dotc/tests.scala
+++ b/test/dotc/tests.scala
@@ -106,9 +106,6 @@ class tests extends CompilerTest {
   @Test def neg_i50_volatile = compileFile(negDir, "i50-volatile", xerrors = 6)
   @Test def neg_t0273_doubledefs = compileFile(negDir, "t0273", xerrors = 1)
   @Test def neg_zoo = compileFile(negDir, "zoo", xerrors = 12)
-  @Test def neg_sam = compileFile(negDir, "sammy_poly", xerrors = 1)
-  // TODO: this test file doesn't exist (anymore?), remove?
-  // @Test def neg_t1192_legalPrefix = compileFile(negDir, "t1192", xerrors = 1)
 
   val negTailcallDir = negDir + "tailcall/"
   @Test def neg_tailcall_t1672b = compileFile(negTailcallDir, "t1672b", xerrors = 6)
diff --git a/tests/neg/sammy_poly.scala b/tests/neg/sammy_poly.scala
deleted file mode 100644
index 8d0236496917..000000000000
--- a/tests/neg/sammy_poly.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-// test synthesizeSAMFunction where the sam type is not fully defined
-class T {
-  trait F[T, U] { def apply(x: T): U }
-  // this is an inner trait, that will recieve an abstract $outer pointer. Not a SAM.
-  def app[T, U](x: T)(f: F[T, U]): U = f(x)
-  app(1)(x => List(x))
-}
diff --git a/tests/pos/sams.scala b/tests/pos/sams.scala
new file mode 100644
index 000000000000..671213fefe30
--- /dev/null
+++ b/tests/pos/sams.scala
@@ -0,0 +1,63 @@
+object test {
+
+  trait X { def foo(x: Int): Int; def bar = foo(2) }
+
+  val x: X = (x: Int) => 2  // should be a closure
+
+  trait T {
+    var f = 2
+    def foo(x: Int): Int
+  }
+
+  val t: T = (x: Int) => 2   // needs to be an anonymous class because of defined field
+
+  trait U extends T
+
+  val u: U = (x: Int) => 2   // needs to be an anonymous class because of inherited field
+
+  trait Y extends X {
+    def baz = super.bar
+  }
+
+  val y: Y = (x: Int) => 2   // needs to be an anonymous class because of super accessor
+
+  abstract class C {
+    def foo(x: Int): Int
+
+    trait I { def foo(x: Int): Int }
+
+  }
+
+  val c: C = (x: Int) => 2   // needs to be an anonymous class because C is not a trait
+
+  val ci: c.I = (x: Int) => 2 // needs to be an anonymous class because it needs an outer pointer
+
+
+  val pf: PartialFunction[Int, Int] = {
+    case 1 => 1
+    case 2 => 2
+  }
+
+  val qf: PartialFunction[(Int, String), Int] = {
+    case (1, "abc") => 1
+    case _ => 2
+  }
+
+  val rf: PartialFunction[(Int, AnyRef), Int] = {
+    case (_: Int, _: String) => 1
+    case _ => 2
+  }
+
+  val sf: PartialFunction[Any, Int] = {
+    case x: String if x == "abc" => 1
+  }
+}
+
+// From: neg/sammy_poly
+// synthesizeSAMFunction where the sam type is not fully defined
+class T {
+  trait F[T, U] { def apply(x: T): U }
+  // this is an inner trait, that will recieve an abstract $outer pointer. Not a SAM.
+  def app[T, U](x: T)(f: F[T, U]): U = f(x)
+  app(1)(x => List(x))
+}

From 3df53946319d7f6c7af6e0eca757e548b6bc5cef Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 30 Apr 2015 11:30:44 +0200
Subject: [PATCH 07/13] Make sure types of pattern bound variables are
 fully-defined.

Like all other variables, pattern-bound vars need a fully defined type. I was
thinking originally that demanding a fully defined selector type is sufficient
to ensure this, but that's not true: An outer pattern might call a polymorphic
unapply and its type variables need not be fully instantiated.

With the fix, the minimized test case from ExpandSAMs works.
---
 src/dotty/tools/dotc/typer/Typer.scala | 5 +++--
 tests/pos/Patterns.scala               | 5 +++++
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala
index b58f4872870c..191a13ad08a2 100644
--- a/src/dotty/tools/dotc/typer/Typer.scala
+++ b/src/dotty/tools/dotc/typer/Typer.scala
@@ -844,8 +844,9 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
   }
 
   def typedBind(tree: untpd.Bind, pt: Type)(implicit ctx: Context): Bind = track("typedBind") {
-    val body1 = typed(tree.body, pt)
-    typr.println(i"typed bind $tree pt = $pt bodytpe = ${body1.tpe}")
+    val pt1 = fullyDefinedType(pt, "pattern variable", tree.pos)
+    val body1 = typed(tree.body, pt1)
+    typr.println(i"typed bind $tree pt = $pt1 bodytpe = ${body1.tpe}")
     val flags = if (tree.isType) BindDefinedType else EmptyFlags
     val sym = ctx.newSymbol(ctx.owner, tree.name, flags, body1.tpe, coord = tree.pos)
     assignType(cpy.Bind(tree)(tree.name, body1), sym)
diff --git a/tests/pos/Patterns.scala b/tests/pos/Patterns.scala
index e443c2ab5c3f..e9bce87a933e 100644
--- a/tests/pos/Patterns.scala
+++ b/tests/pos/Patterns.scala
@@ -94,3 +94,8 @@ object Patterns {
       t
   }
 }
+
+object NestedPattern {
+  val xss: List[List[String]] = ???
+  val List(List(x)) = xss
+}

From 464ef81915cd428fc8918a2943ea4401ab0ef30a Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 30 Apr 2015 11:45:01 +0200
Subject: [PATCH 08/13] Remove worksround in ExpandSAMs

Removed the workaround of the original crasher which was addressed in the last commit.
---
 src/dotty/tools/dotc/transform/ExpandSAMs.scala | 15 +--------------
 1 file changed, 1 insertion(+), 14 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/ExpandSAMs.scala b/src/dotty/tools/dotc/transform/ExpandSAMs.scala
index 1340a206728d..1f822a12c10d 100644
--- a/src/dotty/tools/dotc/transform/ExpandSAMs.scala
+++ b/src/dotty/tools/dotc/transform/ExpandSAMs.scala
@@ -41,21 +41,8 @@ class ExpandSAMs extends MiniPhaseTransform { thisTransformer =>
 
   private def toPartialFunction(tree: Block)(implicit ctx: Context, info: TransformerInfo): Tree = {
     val Block(
-          (applyDef @ DefDef(nme.ANON_FUN, Nil, List(params), _, _)) :: Nil,
+          (applyDef @ DefDef(nme.ANON_FUN, Nil, List(List(param)), _, _)) :: Nil,
           Closure(_, _, tpt)) = tree
-    val List(param) = params
-    // Dotty problem: If we match instead List(List(param)) directly,
-    // we get:
-    // Exception in thread "main" java.lang.AssertionError: assertion failed: self instantiation of (A?
-    // ...
-    //  at scala.Predef$.assert(Predef.scala:165)
-    //  at dotty.tools.dotc.core.Types$TypeVar.instantiateWith(Types.scala:2308)
-    //  at dotty.tools.dotc.core.Types$TypeVar.instantiate(Types.scala:2363)
-    //  at dotty.tools.dotc.typer.Inferencing$$anonfun$interpolate$1$1$$anonfun$apply$mcV$sp$4.apply(Inferencing.scala:198)
-    // at dotty.tools.dotc.typer.Inferencing$$anonfun$interpolate$1$1$$anonfun$apply$mcV$sp$4.apply(Inferencing.scala:195)
-    //
-    // I think it has to do with the double :: (or List) pattern to extract `param`.
-
     val applyRhs: Tree = applyDef.rhs
     val applyFn = applyDef.symbol.asTerm
 

From c395a2543ac0ad9ea53568b6b52d0effc5964645 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 30 Apr 2015 12:02:08 +0200
Subject: [PATCH 09/13] Generalize tpd.AnonClass

Now takes a list of parent types. We needed only one parent for SAM implementation
but it makes sense to generalize this.

Also, removed redundant code accidentally left in.
---
 src/dotty/tools/dotc/ast/tpd.scala            | 19 +++++++++----------
 .../tools/dotc/transform/ExpandSAMs.scala     |  4 ++--
 2 files changed, 11 insertions(+), 12 deletions(-)

diff --git a/src/dotty/tools/dotc/ast/tpd.scala b/src/dotty/tools/dotc/ast/tpd.scala
index 4df3f7a63c38..dce06da958f7 100644
--- a/src/dotty/tools/dotc/ast/tpd.scala
+++ b/src/dotty/tools/dotc/ast/tpd.scala
@@ -247,22 +247,21 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   /** An anonymous class
    *
-   *      new parent { forwarders }
+   *      new parents { forwarders }
    *
    *  where `forwarders` contains forwarders for all functions in `fns`.
-   *  `fns` must be non-empty. The class has the same owner as the first function in `fns`.
+   *  @param parents    a non-empty list of class types
+   *  @param fns        a non-empty of functions for which forwarders should be defined in the class.
+   *  The class has the same owner as the first function in `fns`.
    *  Its position is the union of all functions in `fns`.
    */
-  def AnonClass(parent: Type, fns: List[TermSymbol], methNames: List[TermName])(implicit ctx: Context): Block = {
-    def methName(fnName: TermName): TermName = if (fnName == nme.ANON_FUN) nme.apply else fnName
+  def AnonClass(parents: List[Type], fns: List[TermSymbol], methNames: List[TermName])(implicit ctx: Context): Block = {
     val owner = fns.head.owner
-    val parents =
-      if (parent.classSymbol.is(Trait)) defn.ObjectClass.typeRef :: parent :: Nil
-      else parent :: Nil
-    val cls = ctx.newNormalizedClassSymbol(owner, tpnme.ANON_FUN, Synthetic, parents,
+    val parents1 =
+      if (parents.head.classSymbol.is(Trait)) defn.ObjectClass.typeRef :: parents
+      else parents
+    val cls = ctx.newNormalizedClassSymbol(owner, tpnme.ANON_FUN, Synthetic, parents1,
         coord = fns.map(_.pos).reduceLeft(_ union _))
-    println(i"creating anon class with parent $parent -> ${cls.info.parents}%, %")
-    println(cls.classInfo.classParents)
     val constr = ctx.newConstructor(cls, Synthetic, Nil, Nil).entered
     def forwarder(fn: TermSymbol, name: TermName) = {
       val fwdMeth = fn.copy(cls, name, Synthetic | Method).entered.asTerm
diff --git a/src/dotty/tools/dotc/transform/ExpandSAMs.scala b/src/dotty/tools/dotc/transform/ExpandSAMs.scala
index 1f822a12c10d..3b151dc31efc 100644
--- a/src/dotty/tools/dotc/transform/ExpandSAMs.scala
+++ b/src/dotty/tools/dotc/transform/ExpandSAMs.scala
@@ -33,7 +33,7 @@ class ExpandSAMs extends MiniPhaseTransform { thisTransformer =>
           else tree
         case tpe =>
           cpy.Block(tree)(stats,
-              AnonClass(tpe, fn.symbol.asTerm :: Nil, nme.apply :: Nil))
+              AnonClass(tpe :: Nil, fn.symbol.asTerm :: Nil, nme.apply :: Nil))
       }
     case _ =>
       tree
@@ -72,7 +72,7 @@ class ExpandSAMs extends MiniPhaseTransform { thisTransformer =>
         tru
     }
     val isDefinedAtDef = transformFollowingDeep(DefDef(isDefinedAtFn, isDefinedAtRhs(_)))
-    val anonCls = AnonClass(tpt.tpe, List(applyFn, isDefinedAtFn), List(nme.apply, nme.isDefinedAt))
+    val anonCls = AnonClass(tpt.tpe :: Nil, List(applyFn, isDefinedAtFn), List(nme.apply, nme.isDefinedAt))
     cpy.Block(tree)(List(applyDef, isDefinedAtDef), anonCls)
   }
 }

From 7c121a808bdd1cb3112d1471bc5c017e1e1de465 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 30 Apr 2015 15:04:00 +0200
Subject: [PATCH 10/13] Fix noInitMember to apply to DefDefs

Thanks for pointing it out, @smarter.
---
 src/dotty/tools/dotc/ast/TreeInfo.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/ast/TreeInfo.scala b/src/dotty/tools/dotc/ast/TreeInfo.scala
index 6d1c04978e78..13e10105c417 100644
--- a/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -27,7 +27,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   /** Does tree contain an initialization part when seen as a member of a class or trait?
    */
   def isNoInitMember(tree: Tree): Boolean = unsplice(tree) match {
-    case EmptyTree | Import(_, _) | TypeDef(_, _) => true
+    case EmptyTree | Import(_, _) | TypeDef(_, _) | DefDef(_, _, _, _, _) => true
     case tree: ValDef => tree.unforcedRhs == EmptyTree
     case _ => false
   }

From 9be27ae2750b2554cf8d0719a4737f6420042995 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 30 Apr 2015 15:07:08 +0200
Subject: [PATCH 11/13] Refactoring and renaming of superClass/superInterfaces

superClass was a duplicate; we already have one in SymDenotation,
so we delete the one in SymUtils.

superInterfaces is too easy to confused with the JVM notion, which
is different. I replaced with directlyInheritedTraits.
---
 .../backend/jvm/DottyBackendInterface.scala   |  4 ++--
 src/dotty/tools/dotc/transform/SymUtils.scala | 24 ++++++-------------
 2 files changed, 9 insertions(+), 19 deletions(-)

diff --git a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
index 2e904cc23532..fee8b95a2f8f 100644
--- a/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
+++ b/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -647,7 +647,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
     }
     def parentSymbols: List[Symbol] = toDenot(sym).info.parents.map(_.typeSymbol)
     def superClass: Symbol =  {
-      val t = toDenot(sym).superClass
+      val t = toDenot(sym).asClass.superClass
       if (t.exists) t
       else if (sym is Flags.ModuleClass) {
         // workaround #371
@@ -712,7 +712,7 @@ class DottyBackendInterface()(implicit ctx: Context) extends BackendInterface{
      * All interfaces implemented by a class, except for those inherited through the superclass.
      *
      */
-    def superInterfaces: List[Symbol] = decorateSymbol(sym).superInterfaces
+    def superInterfaces: List[Symbol] = decorateSymbol(sym).directlyInheritedTraits
 
     /**
      * True for module classes of package level objects. The backend will generate a mirror class for
diff --git a/src/dotty/tools/dotc/transform/SymUtils.scala b/src/dotty/tools/dotc/transform/SymUtils.scala
index 41a0938b8ee5..9b4b0660126a 100644
--- a/src/dotty/tools/dotc/transform/SymUtils.scala
+++ b/src/dotty/tools/dotc/transform/SymUtils.scala
@@ -24,30 +24,20 @@ object SymUtils {
 class SymUtils(val self: Symbol) extends AnyVal {
   import SymUtils._
 
-  def superClass(implicit ctx: Context) = {
-    val parents = self.asClass.classInfo.parents
-    if (parents.isEmpty) NoSymbol
-    else parents.head.symbol
-  }
-
-
-  /**
-   * For a class: All interfaces implemented by a class except for those inherited through the superclass.
-   * For a trait: all parent traits
-   */
-
-  def superInterfaces(implicit ctx: Context) = {
-    val superCls = self.superClass
+  /** All traits implemented by a class or trait except for those inherited through the superclass. */
+  def directlyInheritedTraits(implicit ctx: Context) = {
+    val superCls = self.asClass.superClass
     val baseClasses = self.asClass.baseClasses
     if (baseClasses.isEmpty) Nil
     else baseClasses.tail.takeWhile(_ ne superCls).reverse
-
   }
 
-  /** All interfaces implemented by a class, except for those inherited through the superclass. */
+  /** All traits implemented by a class, except for those inherited through the superclass.
+   *  The empty list if `self` is a trait.
+   */
   def mixins(implicit ctx: Context) = {
     if (self is Trait) Nil
-    else superInterfaces
+    else directlyInheritedTraits
   }
 
   def isTypeTestOrCast(implicit ctx: Context): Boolean =

From dbe0456b740e841ddd35fd0d9802aff95c7c4426 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 30 Apr 2015 15:09:06 +0200
Subject: [PATCH 12/13] More conditions under which SAMs are converted to
 anonymous classes

Also included are

  - Closures implementing classes that inherit from a class other than Object
  - Closures that implement traits which run initialization code.
---
 src/dotty/tools/dotc/core/Flags.scala         |  2 +-
 .../tools/dotc/transform/ExpandSAMs.scala     | 20 ++++++++++++++-----
 tests/pos/sams.scala                          | 12 +++++++++++
 3 files changed, 28 insertions(+), 6 deletions(-)

diff --git a/src/dotty/tools/dotc/core/Flags.scala b/src/dotty/tools/dotc/core/Flags.scala
index f62c3cae8011..7435f0baf418 100644
--- a/src/dotty/tools/dotc/core/Flags.scala
+++ b/src/dotty/tools/dotc/core/Flags.scala
@@ -332,7 +332,7 @@ object Flags {
   final val JavaStaticTerm = JavaStatic.toTermFlags
   final val JavaStaticType = JavaStatic.toTypeFlags
 
-  /** Trait is not an interface, but does not have fields or initialization code */
+  /** Trait does not have fields or initialization code */
   final val NoInits = typeFlag(32, "<noInits>")
 
   /** Variable is accessed from nested function. */
diff --git a/src/dotty/tools/dotc/transform/ExpandSAMs.scala b/src/dotty/tools/dotc/transform/ExpandSAMs.scala
index 3b151dc31efc..bba42f403de3 100644
--- a/src/dotty/tools/dotc/transform/ExpandSAMs.scala
+++ b/src/dotty/tools/dotc/transform/ExpandSAMs.scala
@@ -5,15 +5,19 @@ import core._
 import Contexts._, Symbols._, Types._, Flags._, Decorators._, StdNames._, Constants._
 import SymDenotations.SymDenotation
 import TreeTransforms._
+import SymUtils._
 import ast.untpd
 import ast.Trees._
 
-/** Expand SAM closures that cannot be represented by the JVM to anonymous classes.
- *  These fall into three categories
+/** Expand SAM closures that cannot be represented by the JVM as lambdas to anonymous classes.
+ *  These fall into five categories
  *
  *   1. Partial function closures, we need to generate a isDefinedAt method for these.
- *   2. Closures implementaing non-trait classes.
- *   3. Closures that get synthesized abstract methods in the transformation pipeline. These methods can be
+ *   2. Closures implementing non-trait classes.
+ *   3. Closures implementing classes that inherit from a class other than Object
+ *      (a lambda cannot not be a run-time subtype of such a class)
+ *   4. Closures that implement traits which run initialization code.
+ *   5. Closures that get synthesized abstract methods in the transformation pipeline. These methods can be
  *      (1) superaccessors, (2) outer references, (3) accessors for fields.
  */
 class ExpandSAMs extends MiniPhaseTransform { thisTransformer =>
@@ -22,7 +26,13 @@ class ExpandSAMs extends MiniPhaseTransform { thisTransformer =>
   import ast.tpd._
 
   def noJvmSam(cls: ClassSymbol)(implicit ctx: Context): Boolean =
-    !cls.is(Trait) || ExplicitOuter.needsOuterIfReferenced(cls) || cls.typeRef.fields.nonEmpty
+    !cls.is(Trait) ||
+    cls.superClass != defn.ObjectClass ||
+    !cls.is(NoInits) ||
+    !cls.directlyInheritedTraits.forall(_.is(NoInits)) ||
+    ExplicitOuter.needsOuterIfReferenced(cls) ||
+    cls.typeRef.fields.nonEmpty // Superaccessors already show up as abstract methods here, so no test necessary
+
 
   override def transformBlock(tree: Block)(implicit ctx: Context, info: TransformerInfo): Tree = tree match {
     case Block(stats @ (fn: DefDef) :: Nil, Closure(_, fnRef, tpt)) if fnRef.symbol == fn.symbol =>
diff --git a/tests/pos/sams.scala b/tests/pos/sams.scala
index 671213fefe30..b7ef7dd2d432 100644
--- a/tests/pos/sams.scala
+++ b/tests/pos/sams.scala
@@ -15,12 +15,24 @@ object test {
 
   val u: U = (x: Int) => 2   // needs to be an anonymous class because of inherited field
 
+  trait V extends Exception { def foo(x: Int): Int }
+
+  val v: V = (x: Int) => 2   // needs to be an anonymous class because the trait extends a non-object class
+
   trait Y extends X {
     def baz = super.bar
   }
 
   val y: Y = (x: Int) => 2   // needs to be an anonymous class because of super accessor
 
+  trait Z {
+    def foo(x: Int): Int; println("hi there!")
+  }
+  trait ZZ extends Z
+
+  val z: Z = (x: Int) => 2   // needs to be an anonymous class because trait has initialization code
+  val zz: ZZ = (x: Int) => 2   // needs to be an anonymous class becaiuse trait has initialization code
+
   abstract class C {
     def foo(x: Int): Int
 

From 349c436348407b0e862e3feb65c959275549d86b Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Thu, 30 Apr 2015 15:09:36 +0200
Subject: [PATCH 13/13] Failing test

The test included here fails in backend.
---
 tests/disabled/simplesams.scala | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 tests/disabled/simplesams.scala

diff --git a/tests/disabled/simplesams.scala b/tests/disabled/simplesams.scala
new file mode 100644
index 000000000000..14a7ba6c024f
--- /dev/null
+++ b/tests/disabled/simplesams.scala
@@ -0,0 +1,9 @@
+package test
+
+trait X { def foo(x: Int): Int; def bar = foo(2) }
+trait XX extends X
+
+object test {
+  val x: X = (x: Int) => 2  // should be a closure
+  val xx: XX = (x: Int) => 2  // should be a closure, but blows up in backend
+}