|
| 1 | +package dotty.tools.dotc |
| 2 | +package transform |
| 3 | + |
| 4 | +import core.Phases._ |
| 5 | +import core.DenotTransformers._ |
| 6 | +import core.Symbols._ |
| 7 | +import core.Contexts._ |
| 8 | +import core.Types._ |
| 9 | +import core.Decorators._ |
| 10 | +import dotty.tools.dotc.ast.{Trees, tpd} |
| 11 | +import ast.Trees._ |
| 12 | + |
| 13 | +import dotty.tools.dotc.core.Flags |
| 14 | +import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo, TreeTransform} |
| 15 | + |
| 16 | +import scala.annotation.tailrec |
| 17 | + |
| 18 | +class PhantomErasure extends MiniPhaseTransform with InfoTransformer { |
| 19 | + thisTransformer => |
| 20 | + |
| 21 | + import dotty.tools.dotc.ast.tpd._ |
| 22 | + |
| 23 | + override def phaseName: String = "phantomErasure" |
| 24 | + |
| 25 | + /** List of names of phases that should precede this phase */ |
| 26 | + override def runsAfter: Set[Class[_ <: Phase]] = |
| 27 | + Set(classOf[InterceptedMethods], classOf[Splitter], classOf[ElimRepeated]) |
| 28 | + |
| 29 | + /** Check what the phase achieves, to be called at any point after it is finished. |
| 30 | + */ |
| 31 | + override def checkPostCondition(tree: tpd.Tree)(implicit ctx: Context): Unit = { |
| 32 | + def assertNotPhantom(tpe: Type): Unit = |
| 33 | + assert(!tpe.derivesFrom(defn.PhantomAnyClass), "All phantom type values should be erased in " + tree) |
| 34 | + |
| 35 | + tree match { |
| 36 | + case _: TypeTree => |
| 37 | + case _: Trees.TypeDef[_] => |
| 38 | + case ValDef(_, tpt, _) => assertNotPhantom(tpt.typeOpt) |
| 39 | + case DefDef(_, _, _, tpt, _) => assertNotPhantom(tpt.typeOpt) |
| 40 | + case _ => assertNotPhantom(tree.tpe) |
| 41 | + } |
| 42 | + super.checkPostCondition(tree) |
| 43 | + } |
| 44 | + |
| 45 | + // Transform trees |
| 46 | + |
| 47 | + override def transformStats(trees: List[tpd.Tree])(implicit ctx: Context, info: TransformerInfo): List[tpd.Tree] = { |
| 48 | + val newTrees = trees.filter { |
| 49 | + case ValDef(_, tpt, _) => |
| 50 | + !tpt.tpe.derivesFrom(defn.PhantomAnyClass) |
| 51 | + |
| 52 | + case tree @ DefDef(_, _, _, tpt, _) => |
| 53 | + val isPhantom = tpt.tpe.derivesFrom(defn.PhantomAnyClass) |
| 54 | + if (isPhantom && tree.symbol.flags.is(Flags.Accessor)) { |
| 55 | + if (tree.symbol.flags.is(Flags.Mutable)) |
| 56 | + ctx.error("Can not define var with phantom type.", tree.pos) |
| 57 | + else if (tree.symbol.flags.is(Flags.Lazy)) |
| 58 | + ctx.error("Can not define lazy var with phantom type.", tree.pos) |
| 59 | + } |
| 60 | + !isPhantom |
| 61 | + |
| 62 | + case tree @ Apply(fun, _) if tree.tpe.derivesFrom(defn.PhantomAnyClass) => |
| 63 | + ctx.error(s"Functions returning a phantom type can not be in statement position.", fun.pos) |
| 64 | + false |
| 65 | + case tree @ TypeApply(fun, _) if tree.tpe.derivesFrom(defn.PhantomAnyClass) => |
| 66 | + ctx.error(s"Functions returning a phantom type can not be in statement position.", fun.pos) |
| 67 | + false |
| 68 | + case tree: Select if tree.tpe.derivesFrom(defn.PhantomAnyClass) => |
| 69 | + ctx.error(s"Fields containing a phantom type can not be accessed in statement position.", tree.pos) |
| 70 | + false |
| 71 | + |
| 72 | + case _ => |
| 73 | + true |
| 74 | + } |
| 75 | + super.transformStats(newTrees) |
| 76 | + } |
| 77 | + |
| 78 | + override def transformApply(tree: Apply)(implicit ctx: Context, info: TransformerInfo): Tree = { |
| 79 | + val paramTypes = { |
| 80 | + tree.fun.typeOpt match { |
| 81 | + case tpe: TermRef => |
| 82 | + tpe.info match { |
| 83 | + case tpe2: MethodType => tpe2.paramTypes |
| 84 | + case _ => Nil |
| 85 | + } |
| 86 | + |
| 87 | + case tpe: MethodType => tpe.paramTypes |
| 88 | + case _ => Nil |
| 89 | + } |
| 90 | + } |
| 91 | + |
| 92 | + val newTree = |
| 93 | + if (paramTypes.nonEmpty || tree.args.isEmpty) tree |
| 94 | + else cpy.Apply(tree)(tree.fun, Nil) |
| 95 | + |
| 96 | + super.transformApply(newTree) |
| 97 | + } |
| 98 | + |
| 99 | + override def transformDefDef(ddef: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = { |
| 100 | + def filterPhantom(vparamss: List[List[ValDef]]): List[List[ValDef]] = { |
| 101 | + vparamss.filter { vparams => |
| 102 | + val phantoms = vparams.filter(_.tpt.typeOpt.derivesFrom(defn.PhantomAnyClass)) |
| 103 | + if (phantoms.nonEmpty && phantoms.size != vparams.size) |
| 104 | + ctx.error("Lists of parameters with runtime and phantom types are not allowed.", vparams.head.pos) |
| 105 | + phantoms.isEmpty |
| 106 | + } |
| 107 | + } |
| 108 | + val newVparamss = filterPhantom(ddef.vparamss) |
| 109 | + val ddef1 = |
| 110 | + if (ddef.vparamss.length == newVparamss.length) ddef |
| 111 | + else cpy.DefDef(ddef)(vparamss = newVparamss) |
| 112 | + super.transformDefDef(ddef1) |
| 113 | + } |
| 114 | + |
| 115 | + // Transform symbols |
| 116 | + |
| 117 | + def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = erasedPhantoms(tp) |
| 118 | + |
| 119 | + private def erasedPhantoms(tp: Type)(implicit ctx: Context): Type = { |
| 120 | + val flags = tp.typeSymbol.flags |
| 121 | + tp match { |
| 122 | + case tp: ClassInfo if !flags.is(Flags.Package) => |
| 123 | + val newDecls = tp.decls.filteredScope(sym => !isPhantomMethodType(sym.info)) |
| 124 | + ClassInfo(tp.prefix, tp.cls, tp.classParents, newDecls, tp.selfInfo) |
| 125 | + |
| 126 | + case tp: JavaMethodType => tp |
| 127 | + case tp: MethodType => erasedMethodPhantoms(tp) |
| 128 | + |
| 129 | + case tp: PolyType => |
| 130 | + PolyType(tp.paramNames)(_ => tp.paramBounds, _ => erasedPhantoms(tp.resType)) |
| 131 | + |
| 132 | + case _ => tp |
| 133 | + } |
| 134 | + } |
| 135 | + |
| 136 | + private def erasedMethodPhantoms(tp: MethodType)(implicit ctx: Context): MethodType = { |
| 137 | + val (erasedParamNames, erasedParamTypes) = |
| 138 | + if (tp.paramTypes.isEmpty || tp.paramTypes.head.derivesFrom(defn.PhantomAnyClass)) (Nil, Nil) |
| 139 | + else (tp.paramNames, tp.paramTypes) |
| 140 | + val erasedResultType = erasedPhantoms(tp.resultType) |
| 141 | + tp match { |
| 142 | + case _: ImplicitMethodType => |
| 143 | + ImplicitMethodType(erasedParamNames, erasedParamTypes, erasedResultType) |
| 144 | + case _ => |
| 145 | + MethodType(erasedParamNames, erasedParamTypes, erasedResultType) |
| 146 | + } |
| 147 | + } |
| 148 | + |
| 149 | + @tailrec private def isPhantomMethodType(tpe: Type)(implicit ctx: Context): Boolean = tpe match { |
| 150 | + case tpe: MethodicType => tpe.resultType.derivesFrom(defn.PhantomAnyClass) || isPhantomMethodType(tpe.resultType) |
| 151 | + case _ => false |
| 152 | + } |
| 153 | +} |
0 commit comments