Implementation of SIP 13 - implicit classes

4 files changed, 119 insertions, 83 deletions

diff --git a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
index 3d8c2ea564..e622ad7d4b 100644
--- a/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/MethodSynthesis.scala
@@ -155,28 +155,23 @@ trait MethodSynthesis {
 
   /** There are two key methods in here.
    *
-   *   1) enterGetterSetter is called from Namer with a ValDef which
-   *   may need accessors.  Some setup is performed.  In general this
-   *   creates symbols and enters them into the scope of the owner.
+   *   1) Enter methods such as enterGetterSetterare called
+   *   from Namer with a tree which may generate further trees such as accessors or
+   *   implicit wrappers. Some setup is performed.  In general this creates symbols
+   *   and enters them into the scope of the owner.
    *
-   *   2) finishGetterSetter is called from Typer when a Template is typed.
+   *   2) addDerivedTrees is called from Typer when a Template is typed.
    *   It completes the job, returning a list of trees with their symbols
-   *   set to those created in enterGetterSetter.  Those trees then become
+   *   set to those created in the enter methods.  Those trees then become
    *   part of the typed template.
    */
   trait MethodSynth {
     self: Namer =>
 
     import NamerErrorGen._
-    
-    /** TODO - synthesize method.
-     */
-    def enterImplicitClass(tree: ClassDef) {
-      /** e.g.
-      val ClassDef(mods, name, tparams, impl) = tree
-      val converter = ImplicitClassConverter(tree).createAndEnterSymbol()
-      ...
-      */
+
+    def enterImplicitWrapper(tree: ClassDef) {
+      ImplicitClassWrapper(tree).createAndEnterSymbol()
     }
 
     def enterGetterSetter(tree: ValDef) {
@@ -203,7 +198,8 @@ trait MethodSynthesis {
 
       enterBeans(tree)
     }
-    def finishGetterSetter(typer: Typer, stat: Tree): List[Tree] = stat match {
+
+    def addDerivedTrees(typer: Typer, stat: Tree): List[Tree] = stat match {
       case vd @ ValDef(mods, name, tpt, rhs) if !noFinishGetterSetter(vd) && !vd.symbol.isLazy =>
         // If we don't save the annotations, they seem to wander off.
         val annotations = stat.symbol.initialize.annotations
@@ -234,35 +230,59 @@ trait MethodSynthesis {
       field ::: standardAccessors(vd) ::: beanAccessors(vd)
     }
 
+    /** This trait assembles what's needed for synthesizing derived methods.
+     *  Important: Typically, instances of this trait are created TWICE for each derived
+     *  symbol; once form Namers in an enter method, and once from Typers in addDerivedTrees.
+     *  So it's important that creating an instance of Derived does not have a side effect,
+     *  or if it has a side effect, control that it is done only once.
+     */
     trait Derived {
-      /** The tree from which we are deriving a synthetic member. */
+
+      /** The tree from which we are deriving a synthetic member. Typically, that's
+       *  given as an argument of the instance. */
       def tree: Tree
+
+      /** The name of the method */
       def name: TermName
+
+      /** The flags that are retained from the original symbol */
+
       def flagsMask: Long
+
+      /** The flags that the derived symbol has in addition to those retained from
+       *  the original symbol*/
       def flagsExtra: Long
-      
-      /** The tree, symbol, and type completer for the synthetic member. */
+
+      /** type completer for the synthetic member.
+       */
       def completer(sym: Symbol): Type
+
+      /** The derived symbol. It is assumed that this symbol already exists and has been
+       *  entered in the parent scope when derivedSym is called */
       def derivedSym: Symbol
+
+      /** The definition tree of the derived symbol. */
       def derivedTree: Tree
     }
-    
+
     trait DerivedFromMemberDef extends Derived {
       def tree: MemberDef
-      
+      def enclClass: Symbol
+
       // Final methods to make the rest easier to reason about.
       final def mods               = tree.mods
       final def basisSym           = tree.symbol
-      final def enclClass          = basisSym.enclClass
       final def derivedFlags: Long = basisSym.flags & flagsMask | flagsExtra
     }
-    
+
     trait DerivedFromClassDef extends DerivedFromMemberDef {
       def tree: ClassDef
+      final def enclClass = basisSym.owner.enclClass
     }
 
     trait DerivedFromValDef extends DerivedFromMemberDef {
       def tree: ValDef
+      final def enclClass = basisSym.enclClass
 
       /** Which meta-annotation is associated with this kind of entity.
        *  Presently one of: field, getter, setter, beanGetter, beanSetter, param.
@@ -334,15 +354,22 @@ trait MethodSynthesis {
     /** A synthetic method which performs the implicit conversion implied by
      *  the declaration of an implicit class.  Yet to be written.
      */
-    case class ImplicitClassConverter(tree: ClassDef) extends DerivedFromClassDef {
-      def completer(sym: Symbol): Type = ???
-      def derivedSym: Symbol           = ???
-      def derivedTree: DefDef          = ???
-      def flagsExtra: Long             = ???
-      def flagsMask: Long              = ???
-      def name: TermName               = ???
-    }
-    
+    case class ImplicitClassWrapper(tree: ClassDef) extends DerivedFromClassDef {
+      def completer(sym: Symbol): Type = ??? // not needed
+      def createAndEnterSymbol(): Symbol = enterSyntheticSym(derivedTree)
+      def derivedSym: Symbol = {
+        val result = enclClass.info decl name
+        assert(result != NoSymbol, "not found: "+name+" in "+enclClass+" "+enclClass.info.decls)
+        result
+      }
+      def derivedTree: DefDef          = util.trace("derivedTree = ")(
+        factoryMeth(mods & flagsMask | flagsExtra, name, tree, symbolic = false)
+      )
+      def flagsExtra: Long             = METHOD | IMPLICIT
+      def flagsMask: Long              = AccessFlags
+      def name: TermName               = nme.implicitWrapperName(tree.name)
+    }
+
     case class Getter(tree: ValDef) extends DerivedGetter {
       def name       = tree.name
       def category   = GetterTargetClass
diff --git a/src/compiler/scala/tools/nsc/typechecker/Namers.scala b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
index 2539091966..98f845f403 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Namers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Namers.scala
@@ -99,7 +99,7 @@ trait Namers extends MethodSynthesis {
       owner.unsafeTypeParams foreach (paramContext.scope enter _)
       newNamer(paramContext)
     }
-    
+
     def enclosingNamerWithScope(scope: Scope) = {
       var cx = context
       while (cx != NoContext && cx.scope != scope) cx = cx.outer
@@ -666,10 +666,12 @@ trait Namers extends MethodSynthesis {
           "If possible, define " + tree.symbol + " in " + owner.skipPackageObject + " instead."
         )
       }
-      
+
       // Suggested location only.
-      if (mods.isImplicit)
-        enterImplicitClass(tree)
+      if (mods.isImplicit) {
+        println("enter implicit wrapper "+tree+", owner = "+owner)
+        enterImplicitWrapper(tree)
+      }
     }
 
     // this logic is needed in case typer was interrupted half
@@ -1404,10 +1406,10 @@ trait Namers extends MethodSynthesis {
       if (sym.isImplicit) {
         if (sym.isConstructor)
           fail(ImplicitConstr)
-        if (!sym.isTerm)
-          fail(ImplicitNotTerm)
+        if (!(sym.isTerm || (sym.isClass && !sym.isTrait)))
+          fail(ImplicitNotTermOrClass)
         if (sym.owner.isPackageClass)
-          fail(ImplicitTopObject)
+          fail(ImplicitAtToplevel)
       }
       if (sym.isClass) {
         if (sym.isAnyOverride && !sym.hasFlag(TRAIT))
diff --git a/src/compiler/scala/tools/nsc/typechecker/Typers.scala b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
index f558e0afc7..9b09145dc3 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Typers.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Typers.scala
@@ -1653,7 +1653,7 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
 
       val body =
         if (isPastTyper || reporter.hasErrors) templ.body
-        else templ.body flatMap rewrappingWrapperTrees(namer.finishGetterSetter(Typer.this, _))
+        else templ.body flatMap rewrappingWrapperTrees(namer.addDerivedTrees(Typer.this, _))
 
       val body1 = typedStats(body, templ.symbol)
 
@@ -2474,54 +2474,53 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
         || (looker.hasAccessorFlag && !accessed.hasAccessorFlag && accessed.isPrivate)
       )
 
-      def checkNoDoubleDefsAndAddSynthetics(stats: List[Tree]): List[Tree] = {
+      def checkNoDoubleDefs(stats: List[Tree]): Unit = {
         val scope = if (inBlock) context.scope else context.owner.info.decls
-        var newStats = new ListBuffer[Tree]
-        var needsCheck = true
-        var moreToAdd = true
-        while (moreToAdd) {
-          val initSize = scope.size
-          var e = scope.elems
-          while ((e ne null) && e.owner == scope) {
-
-            // check no double def
-            if (needsCheck) {
-              var e1 = scope.lookupNextEntry(e)
-              while ((e1 ne null) && e1.owner == scope) {
-                if (!accesses(e.sym, e1.sym) && !accesses(e1.sym, e.sym) &&
-                    (e.sym.isType || inBlock || (e.sym.tpe matches e1.sym.tpe) || e.sym.isMacro && e1.sym.isMacro))
-                  // default getters are defined twice when multiple overloads have defaults. an
-                  // error for this is issued in RefChecks.checkDefaultsInOverloaded
-                  if (!e.sym.isErroneous && !e1.sym.isErroneous && !e.sym.hasDefault &&
-                      !e.sym.hasAnnotation(BridgeClass) && !e1.sym.hasAnnotation(BridgeClass)) {
-                    log("Double definition detected:\n  " +
-                      ((e.sym.getClass, e.sym.info, e.sym.ownerChain)) + "\n  " +
-                      ((e1.sym.getClass, e1.sym.info, e1.sym.ownerChain)))
-
-                    DefDefinedTwiceError(e.sym, e1.sym)
-                    scope.unlink(e1) // need to unlink to avoid later problems with lub; see #2779
-                  }
-                e1 = scope.lookupNextEntry(e1)
+        var e = scope.elems
+        while ((e ne null) && e.owner == scope) {
+          var e1 = scope.lookupNextEntry(e)
+          while ((e1 ne null) && e1.owner == scope) {
+            if (!accesses(e.sym, e1.sym) && !accesses(e1.sym, e.sym) &&
+                (e.sym.isType || inBlock || (e.sym.tpe matches e1.sym.tpe)))
+              // default getters are defined twice when multiple overloads have defaults. an
+              // error for this is issued in RefChecks.checkDefaultsInOverloaded
+              if (!e.sym.isErroneous && !e1.sym.isErroneous && !e.sym.hasDefaultFlag &&
+                  !e.sym.hasAnnotation(BridgeClass) && !e1.sym.hasAnnotation(BridgeClass)) {
+                log("Double definition detected:\n  " +
+                    ((e.sym.getClass, e.sym.info, e.sym.ownerChain)) + "\n  " +
+                    ((e1.sym.getClass, e1.sym.info, e1.sym.ownerChain)))
+
+                DefDefinedTwiceError(e.sym, e1.sym)
+                scope.unlink(e1) // need to unlink to avoid later problems with lub; see #2779
               }
-            }
-
-          // add synthetics
-          context.unit.synthetics get e.sym foreach { tree =>
-            newStats += typedStat(tree) // might add even more synthetics to the scope
-            context.unit.synthetics -= e.sym
+              e1 = scope.lookupNextEntry(e1)
           }
-
           e = e.next
         }
-        needsCheck = false
-        // the type completer of a synthetic might add more synthetics. example: if the
-        // factory method of a case class (i.e. the constructor) has a default.
-        moreToAdd = initSize != scope.size
+      }
+
+      def addSynthetics(stats: List[Tree]): List[Tree] = {
+        val scope = if (inBlock) context.scope else context.owner.info.decls
+        var newStats = new ListBuffer[Tree]
+        var moreToAdd = true
+        while (moreToAdd) {
+          val initElems = scope.elems
+          for (sym <- scope)
+            for (tree <- context.unit.synthetics get sym) {
+              newStats += typedStat(tree) // might add even more synthetics to the scope
+              context.unit.synthetics -= sym
+            }
+          // the type completer of a synthetic might add more synthetics. example: if the
+          // factory method of a case class (i.e. the constructor) has a default.
+          moreToAdd = scope.elems ne initElems
         }
         if (newStats.isEmpty) stats
         else {
           // put default getters next to the method they belong to,
           // same for companion objects. fixes #2489 and #4036.
+          // [Martin] This is pretty ugly. I think we could avoid
+          // this code by associating defaults and companion objects
+          // with the original tree instead of the new symbol.
           def matches(stat: Tree, synt: Tree) = (stat, synt) match {
             case (DefDef(_, statName, _, _, _, _), DefDef(mods, syntName, _, _, _, _)) =>
               mods.hasDefaultFlag && syntName.toString.startsWith(statName.toString)
@@ -2551,7 +2550,10 @@ trait Typers extends Modes with Adaptations with PatMatVirtualiser {
       }
       context.updateBuffer(statsErrors)
       if (phase.erasedTypes) stats1
-      else checkNoDoubleDefsAndAddSynthetics(stats1)
+      else {
+        checkNoDoubleDefs(stats1)
+        addSynthetics(stats1)
+      }
     }
 
     def typedArg(arg: Tree, mode: Int, newmode: Int, pt: Type): Tree = {
diff --git a/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala b/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala
index 4f5b6868ae..1f79d8212d 100644
--- a/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala
+++ b/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala
@@ -112,8 +112,8 @@ trait Unapplies extends ast.TreeDSL
 
   private def toIdent(x: DefTree) = Ident(x.name) setPos x.pos.focus
 
-  private def classType(cdef: ClassDef, tparams: List[TypeDef]): Tree = {
-    val tycon = REF(cdef.symbol)
+  private def classType(cdef: ClassDef, tparams: List[TypeDef], symbolic: Boolean = true): Tree = {
+    val tycon = if (symbolic) REF(cdef.symbol) else Ident(cdef.name)
     if (tparams.isEmpty) tycon else AppliedTypeTree(tycon, tparams map toIdent)
   }
 
@@ -166,15 +166,20 @@ trait Unapplies extends ast.TreeDSL
 
   /** The apply method corresponding to a case class
    */
-  def caseModuleApplyMeth(cdef: ClassDef): DefDef = {
+  def factoryMeth(mods: Modifiers, name: TermName, cdef: ClassDef, symbolic: Boolean): DefDef = {
     val tparams   = cdef.tparams map copyUntypedInvariant
     val cparamss  = constrParamss(cdef)
+    def classtpe = classType(cdef, tparams, symbolic)
     atPos(cdef.pos.focus)(
-      DefDef(caseMods, nme.apply, tparams, cparamss, classType(cdef, tparams),
-        New(classType(cdef, tparams), mmap(cparamss)(gen.paramToArg)))
+      DefDef(mods, name, tparams, cparamss, classtpe,
+        New(classtpe, mmap(cparamss)(gen.paramToArg)))
     )
   }
 
+  /** The apply method corresponding to a case class
+   */
+  def caseModuleApplyMeth(cdef: ClassDef): DefDef = factoryMeth(caseMods, nme.apply, cdef, symbolic = true)
+
   /** The unapply method corresponding to a case class
    */
   def caseModuleUnapplyMeth(cdef: ClassDef): DefDef = {