From 587a1f45f5cbd8f746b01777ac9b100743161633 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Mon, 20 Mar 2017 15:51:39 +0100 Subject: Handle shadowed for TermRefWithSig Making a name shadowed lost the signature before. --- compiler/src/dotty/tools/dotc/core/Types.scala | 12 ++++++++---- 1 file changed, 8 insertions(+), 4 deletions(-) (limited to 'compiler/src') diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala index 6c27e53f6..c80107f93 100644 --- a/compiler/src/dotty/tools/dotc/core/Types.scala +++ b/compiler/src/dotty/tools/dotc/core/Types.scala @@ -1719,7 +1719,7 @@ object Types { * under both private and public names, so it could still be found by looking up * the public name. */ - final def shadowed(implicit ctx: Context): NamedType = + def shadowed(implicit ctx: Context): NamedType = NamedType(prefix, name.shadowedName) override def equals(that: Any) = that match { @@ -1782,15 +1782,19 @@ object Types { else d.atSignature(sig).checkUnique } - override def newLikeThis(prefix: Type)(implicit ctx: Context): TermRef = { - val candidate = TermRef.withSig(prefix, name, sig) + private def fixDenot(candidate: TermRef, prefix: Type)(implicit ctx: Context): TermRef = if (symbol.exists && !candidate.symbol.exists) { // recompute from previous symbol val ownSym = symbol val newd = asMemberOf(prefix, allowPrivate = ownSym.is(Private)) candidate.withDenot(newd.suchThat(_.signature == ownSym.signature)) } else candidate - } + + override def newLikeThis(prefix: Type)(implicit ctx: Context): TermRef = + fixDenot(TermRef.withSig(prefix, name, sig), prefix) + + override def shadowed(implicit ctx: Context): NamedType = + fixDenot(TermRef.withSig(prefix, name.shadowedName, sig), prefix) override def equals(that: Any) = that match { case that: TermRefWithSignature => -- cgit v1.2.3 From 99a77247d1cb4de92b52aa538ce4a2b200383256 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Mon, 20 Mar 2017 15:53:25 +0100 Subject: Use shadowing to reference inherited accessors. Normal references won't work since the referenced accessor has the same name as a private name in the class defining the forwarder. This showed up as pickling failures under separate compilation. --- .../src/dotty/tools/dotc/transform/ParamForwarding.scala | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) (limited to 'compiler/src') diff --git a/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala b/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala index 859ac8b06..a6c4b5d8d 100644 --- a/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala +++ b/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala @@ -4,6 +4,8 @@ package transform import core._ import ast.Trees._ import Contexts._, Types._, Symbols._, Flags._, TypeUtils._, DenotTransformers._, StdNames._ +import Decorators._ +import config.Printers.typr /** For all parameter accessors * @@ -48,7 +50,7 @@ class ParamForwarding(thisTransformer: DenotTransformer) { val candidate = sym.owner.asClass.superClass .info.decl(sym.name).suchThat(_ is (ParamAccessor, butNot = Mutable)).symbol if (candidate.isAccessibleFrom(currentClass.thisType, superAccess = true)) candidate - else if (candidate is Method) inheritedAccessor(candidate) + else if (candidate.exists) inheritedAccessor(candidate) else NoSymbol } def forwardParamAccessor(stat: Tree): Tree = { @@ -66,8 +68,12 @@ class ParamForwarding(thisTransformer: DenotTransformer) { sym.copySymDenotation(initFlags = sym.flags | Method | Stable, info = sym.info.ensureMethodic) .installAfter(thisTransformer) val superAcc = - Super(This(currentClass), tpnme.EMPTY, inConstrCall = false).select(alias) - DefDef(sym, superAcc.ensureConforms(sym.info.widen)) + Super(This(currentClass), tpnme.EMPTY, inConstrCall = false) + .select(alias) + val stpe @ TermRef(_, _) = superAcc.tpe + val superAccShadowed = superAcc.withType(stpe.shadowed) + typr.println(i"adding param forwarder $superAccShadowed") + DefDef(sym, superAccShadowed.ensureConforms(sym.info.widen)) } return forwarder(ctx.withPhase(thisTransformer.next)) } -- cgit v1.2.3 From 20d48d988732ac3c721f31d1a4b8487047b9e92c Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Mon, 20 Mar 2017 17:26:27 +0100 Subject: Only use shadowed when necessary --- .../src/dotty/tools/dotc/transform/ParamForwarding.scala | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) (limited to 'compiler/src') diff --git a/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala b/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala index a6c4b5d8d..2836ebcfe 100644 --- a/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala +++ b/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala @@ -67,13 +67,14 @@ class ParamForwarding(thisTransformer: DenotTransformer) { def forwarder(implicit ctx: Context) = { sym.copySymDenotation(initFlags = sym.flags | Method | Stable, info = sym.info.ensureMethodic) .installAfter(thisTransformer) - val superAcc = - Super(This(currentClass), tpnme.EMPTY, inConstrCall = false) - .select(alias) - val stpe @ TermRef(_, _) = superAcc.tpe - val superAccShadowed = superAcc.withType(stpe.shadowed) - typr.println(i"adding param forwarder $superAccShadowed") - DefDef(sym, superAccShadowed.ensureConforms(sym.info.widen)) + var superAcc = + Super(This(currentClass), tpnme.EMPTY, inConstrCall = false).select(alias) + if (alias.owner != currentClass.superClass) + // need to use shadowed in order not to accidentally address an + // intervening private forwarder in the superclass + superAcc = superAcc.withType(superAcc.tpe.asInstanceOf[TermRef].shadowed) + typr.println(i"adding param forwarder $superAcc") + DefDef(sym, superAcc.ensureConforms(sym.info.widen)) } return forwarder(ctx.withPhase(thisTransformer.next)) } -- cgit v1.2.3