diff options
Diffstat (limited to 'src/compiler/scala/tools/nsc/typechecker/Unapplies.scala')
-rw-r--r-- | src/compiler/scala/tools/nsc/typechecker/Unapplies.scala | 73 |
1 files changed, 46 insertions, 27 deletions
diff --git a/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala b/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala index 4c20d14406..1b89f3db44 100644 --- a/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala +++ b/src/compiler/scala/tools/nsc/typechecker/Unapplies.scala @@ -197,42 +197,61 @@ trait Unapplies extends ast.TreeDSL ) } + /** + * Generates copy methods for case classes. Copy only has defaults on the first + * parameter list, as of SI-5009. + * + * The parameter types of the copy method need to be exactly the same as the parameter + * types of the primary constructor. Just copying the TypeTree is not enough: a type `C` + * might refer to something else *inside* the class (i.e. as parameter type of `copy`) + * than *outside* the class (i.e. in the class parameter list). + * + * One such example is t0054.scala: + * class A { + * case class B(x: C) extends A { def copy(x: C = x) = ... } + * class C {} ^ ^ + * } (1) (2) + * + * The reference (1) to C is `A.this.C`. The reference (2) is `B.this.C` - not the same. + * + * This is fixed with a hack currently. `Unapplies.caseClassCopyMeth`, which creates the + * copy method, uses empty `TypeTree()` nodes for parameter types. + * + * In `Namers.enterDefDef`, the copy method gets a special type completer (`enterCopyMethod`). + * Before computing the body type of `copy`, the class parameter types are assigned the copy + * method parameters. + * + * This attachment class stores the copy method parameter ValDefs as an attachment in the + * ClassDef of the case class. + */ def caseClassCopyMeth(cdef: ClassDef): Option[DefDef] = { def isDisallowed(vd: ValDef) = isRepeatedParamType(vd.tpt) || isByNameParamType(vd.tpt) - val cparamss = constrParamss(cdef) - val flat = cparamss.flatten + val classParamss = constrParamss(cdef) - if (cdef.symbol.hasAbstractFlag || (flat exists isDisallowed)) None + if (cdef.symbol.hasAbstractFlag || mexists(classParamss)(isDisallowed)) None else { + def makeCopyParam(vd: ValDef, putDefault: Boolean) = { + val rhs = if (putDefault) toIdent(vd) else EmptyTree + val flags = PARAM | (vd.mods.flags & IMPLICIT) | (if (putDefault) DEFAULTPARAM else 0) + // empty tpt: see comment above + val tpt = atPos(vd.pos.focus)(TypeTree() setOriginal vd.tpt) + treeCopy.ValDef(vd, Modifiers(flags), vd.name, tpt, rhs) + } + val tparams = cdef.tparams map copyUntypedInvariant - // the parameter types have to be exactly the same as the constructor's parameter types; so it's - // not good enough to just duplicated the (untyped) tpt tree; the parameter types are removed here - // and re-added in ``finishWith'' in the namer. - def paramWithDefault(vd: ValDef) = - treeCopy.ValDef(vd, vd.mods | DEFAULTPARAM, vd.name, atPos(vd.pos.focus)(TypeTree() setOriginal vd.tpt), toIdent(vd)) - - val (copyParamss, funParamss) = cparamss match { - case Nil => (Nil, Nil) + val paramss = classParamss match { + case Nil => Nil case ps :: pss => - (List(ps.map(paramWithDefault)), mmap(pss)(p => copyUntyped[ValDef](p).copy(rhs = EmptyTree))) + ps.map(makeCopyParam(_, putDefault = true)) :: mmap(pss)(makeCopyParam(_, putDefault = false)) } val classTpe = classType(cdef, tparams) - val bodyTpe = funParamss.foldRight(classTpe)((params, restp) => gen.scalaFunctionConstr(params.map(_.tpt), restp)) - - val argss = copyParamss match { - case Nil => Nil - case ps :: _ => mmap(ps :: funParamss)(toIdent) - } - def mkFunction(vparams: List[ValDef], body: Tree) = Function(vparams, body) - val body = funParamss.foldRight(New(classTpe, argss): Tree)(mkFunction) - // [Eugene++] no longer compiles after I moved the `Function` case class into scala.reflect.internal - // val body = funParamss.foldRight(New(classTpe, argss): Tree)(Function) - - Some(atPos(cdef.pos.focus)( - DefDef(Modifiers(SYNTHETIC), nme.copy, tparams, copyParamss, bodyTpe, - body) - )) + val argss = mmap(paramss)(toIdent) + val body: Tree = New(classTpe, argss) + val copyDefDef = atPos(cdef.pos.focus)( + DefDef(Modifiers(SYNTHETIC), nme.copy, tparams, paramss, TypeTree(), body) + ) + Some(copyDefDef) } } } |