|
| 1 | +package dotty.tools.dotc |
| 2 | +package transform |
| 3 | + |
| 4 | +import core._ |
| 5 | +import Constants.Constant |
| 6 | +import Contexts.Context |
| 7 | +import Decorators._ |
| 8 | +import Flags._ |
| 9 | +import ast.Trees._ |
| 10 | +import Definitions._ |
| 11 | +import DenotTransformers._ |
| 12 | +import StdNames._ |
| 13 | +import Symbols._ |
| 14 | +import MegaPhase._ |
| 15 | +import Types._ |
| 16 | +import dotty.tools.dotc.ast.tpd |
| 17 | + |
| 18 | +import scala.annotation.tailrec |
| 19 | + |
| 20 | +/** TODO |
| 21 | + */ |
| 22 | +class GenericTuples extends MiniPhase with IdentityDenotTransformer { |
| 23 | + import tpd._ |
| 24 | + |
| 25 | + def phaseName: String = "genericTuples" |
| 26 | + |
| 27 | + override def transformApply(tree: tpd.Apply)(implicit ctx: Context): tpd.Tree = { |
| 28 | + if (tree.symbol == defn.DynamicTuple_dynamicCons) transformTupleCons(tree) |
| 29 | + else if (tree.symbol == defn.DynamicTuple_dynamicHead) transformTupleHead(tree) |
| 30 | + else if (tree.symbol == defn.DynamicTuple_dynamicTail) transformTupleTail(tree) |
| 31 | + else if (tree.symbol == defn.DynamicTuple_dynamicSize) transformTupleSize(tree) |
| 32 | + else if (tree.symbol == defn.DynamicTuple_dynamicConcat) transformTupleConcat(tree) |
| 33 | + else if (tree.symbol == defn.DynamicTuple_dynamicApply) transformTupleApply(tree) |
| 34 | + else if (tree.symbol == defn.DynamicTuple_dynamicToArray) transformTupleToArray(tree) |
| 35 | + else super.transformApply(tree) |
| 36 | + } |
| 37 | + |
| 38 | + private def transformTupleCons(tree: tpd.Apply)(implicit ctx: Context): Tree = { |
| 39 | + val TypeApply(_, headType :: tailType :: Nil) = tree.fun |
| 40 | + val tail :: head :: Nil = tree.args |
| 41 | + tupleTypes(tree.tpe) match { |
| 42 | + case Some(tpes) => |
| 43 | + val size = tpes.size |
| 44 | + if (size <= 5) { |
| 45 | + // val t = tail |
| 46 | + // TupleN+1(head, t._1, ..., t._n) |
| 47 | + evalOnce(Typed(tail, TypeTree(defn.tupleType(tpes.tail)))) { tup => |
| 48 | + val elements = head :: (0 until size - 1).map(i => tup.select(nme.selectorName(i))).toList |
| 49 | + knownTupleFromElements(tpes, elements) |
| 50 | + } |
| 51 | + } else { |
| 52 | + // val it = Iterator.single(head) ++ tail.asInstanceOf[Product].productIterator |
| 53 | + // TupleN(it.next(), ..., it.next()) |
| 54 | + val fullIterator = ref(defn.DynamicTuple_consIterator).appliedToArgs(head :: tail :: Nil) |
| 55 | + evalOnce(fullIterator) { it => |
| 56 | + knownTupleFromIterator(tpes.length, it).asInstance(tree.tpe) |
| 57 | + } |
| 58 | + } |
| 59 | + case _ => |
| 60 | + // DynamicTuple.dynamicCons:(tail, head) |
| 61 | + tree |
| 62 | + } |
| 63 | + } |
| 64 | + |
| 65 | + private def transformTupleTail(tree: tpd.Apply)(implicit ctx: Context): Tree = { |
| 66 | + val Apply(TypeApply(_, tpt :: Nil), tup :: Nil) = tree |
| 67 | + tupleTypes(tpt.tpe) match { // TODO tupleBoundedTypes |
| 68 | + case Some(tpes) => |
| 69 | + val size = tpes.size |
| 70 | + assert(size > 0) |
| 71 | + if (size == 1) { |
| 72 | + // () |
| 73 | + Literal(Constant(())) |
| 74 | + } |
| 75 | + else if (size <= 5) { |
| 76 | + // val t = tup.asInstanceOf[TupleN[...]] |
| 77 | + // TupleN-1(t._2, ..., t._n) |
| 78 | + evalOnce(Typed(tup, TypeTree(defn.tupleType(tpes)))) { tup => |
| 79 | + val elements = (1 until size).map(i => tup.select(nme.selectorName(i))).toList |
| 80 | + knownTupleFromElements(tpes.tail, elements) |
| 81 | + } |
| 82 | + } else { |
| 83 | + // val it = this.asInstanceOf[Product].productIterator |
| 84 | + // it.next() |
| 85 | + // TupleN(it.next(), ..., it.next()) |
| 86 | + evalOnce(tup.asInstance(defn.ProductType).select(nme.productIterator)) { it => |
| 87 | + Block( |
| 88 | + it.select(nme.next).ensureApplied :: Nil, |
| 89 | + knownTupleFromIterator(size - 1, it).asInstance(tree.tpe) |
| 90 | + ) |
| 91 | + } |
| 92 | + } |
| 93 | + case None => |
| 94 | + // DynamicTuple.dynamicTail(tup) |
| 95 | + tree |
| 96 | + } |
| 97 | + } |
| 98 | + |
| 99 | + private def transformTupleHead(tree: tpd.Apply)(implicit ctx: Context): Tree = { |
| 100 | + val Apply(TypeApply(_, tpt :: Nil), tup :: Nil) = tree |
| 101 | + tupleTypes(tpt.tpe) match { // TODO tupleBoundedTypes |
| 102 | + case Some(tpes) => |
| 103 | + if (tpes.size <= Definitions.MaxTupleArity) { |
| 104 | + // tup._1 |
| 105 | + Typed(tup, TypeTree(defn.tupleType(tpes))).select(nme.selectorName(0)) |
| 106 | + } else { |
| 107 | + // tup.asInstanceOf[TupleXXL].productElement(0) |
| 108 | + tup.asInstance(defn.TupleXXLType).select(nme.productElement).appliedTo(Literal(Constant(0))) |
| 109 | + } |
| 110 | + case None => |
| 111 | + // DynamicTuple.dynamicHead(tup) |
| 112 | + tree |
| 113 | + } |
| 114 | + } |
| 115 | + |
| 116 | + private def transformTupleSize(tree: tpd.Apply)(implicit ctx: Context): Tree = { |
| 117 | + tree.tpe.tryNormalize match { |
| 118 | + case tp: ConstantType => Literal(tp.value) |
| 119 | + case _ => tree |
| 120 | + } |
| 121 | + } |
| 122 | + |
| 123 | + private def transformTupleConcat(tree: tpd.Apply)(implicit ctx: Context): Tree = { |
| 124 | + val Apply(TypeApply(_, selfTp :: thatTp :: Nil), self :: that :: Nil) = tree |
| 125 | + |
| 126 | + (tupleTypes(selfTp.tpe), tupleTypes(that.tpe.widenTermRefExpr)) match { |
| 127 | + case (Some(tpes1), Some(tpes2)) => |
| 128 | + val n = tpes1.size |
| 129 | + val m = tpes2.size |
| 130 | + if (n == 0) that |
| 131 | + else if (m == 0) self |
| 132 | + else if (n + m < 5) { |
| 133 | + // val t = self |
| 134 | + // val u = that |
| 135 | + // TupleN+M(t._1,..., t._N, u._1, ..., u._M) |
| 136 | + evalOnce(Typed(self, TypeTree(defn.tupleType(tpes1)))) { self => |
| 137 | + evalOnce(Typed(that, TypeTree(defn.tupleType(tpes2)))) { that => |
| 138 | + val types = tpes1 ::: tpes2 |
| 139 | + val elements = { |
| 140 | + (0 until n).map(i => self.select(nme.selectorName(i))) ++ |
| 141 | + (0 until m).map(i => that.select(nme.selectorName(i))) |
| 142 | + }.toList |
| 143 | + knownTupleFromElements(types, elements) |
| 144 | + } |
| 145 | + } |
| 146 | + } else { |
| 147 | + // val it = self.asInstanceOf[Product].productIterator ++ that.asInstanceOf[Product].productIterator |
| 148 | + // TupleN(it.next(), ..., it.next()) |
| 149 | + val fullIterator = ref(defn.DynamicTuple_concatIterator).appliedToArgs(tree.args) |
| 150 | + evalOnce(fullIterator) { it => |
| 151 | + knownTupleFromIterator(n + m, it).asInstance(tree.tpe) |
| 152 | + } |
| 153 | + } |
| 154 | + case _ => |
| 155 | + // DynamicTuple.dynamicCons[This, that.type](self, that) |
| 156 | + tree |
| 157 | + } |
| 158 | + } |
| 159 | + |
| 160 | + private def transformTupleApply(tree: tpd.Apply)(implicit ctx: Context): Tree = { |
| 161 | + val Apply(TypeApply(_, tpt :: nTpt :: Nil), tup :: nTree :: Nil) = tree |
| 162 | + (tupleTypes(tpt.tpe), nTpt.tpe) match { |
| 163 | + case (Some(tpes), nTpe: ConstantType) => |
| 164 | + val size = tpes.size |
| 165 | + val n = nTpe.value.intValue |
| 166 | + if (n < 0 || n >= size) { |
| 167 | + ctx.error("index out of bounds: " + n, nTree.underlyingArgument.sourcePos) |
| 168 | + tree |
| 169 | + } else if (size <= Definitions.MaxTupleArity) { |
| 170 | + // tup._n |
| 171 | + Typed(tup, TypeTree(defn.tupleType(tpes))).select(nme.selectorName(n)) |
| 172 | + } else { |
| 173 | + // tup.asInstanceOf[TupleXXL].productElement(n) |
| 174 | + tup.asInstance(defn.TupleXXLType).select(nme.productElement).appliedTo(Literal(nTpe.value)) |
| 175 | + } |
| 176 | + case (None, nTpe: ConstantType) if nTpe.value.intValue < 0 => |
| 177 | + ctx.error("index out of bounds: " + nTpe.value.intValue, nTree.sourcePos) |
| 178 | + tree |
| 179 | + case _ => |
| 180 | + // DynamicTuple.dynamicApply(tup, n) |
| 181 | + tree |
| 182 | + } |
| 183 | + } |
| 184 | + |
| 185 | + private def transformTupleToArray(tree: tpd.Apply)(implicit ctx: Context): Tree = { |
| 186 | + val Apply(_, tup :: Nil) = tree |
| 187 | + tupleTypes(tup.tpe.widen) match { // TODO tupleBoundedTypes |
| 188 | + case Some(tpes) => |
| 189 | + val size = tpes.size |
| 190 | + if (size == 0) { |
| 191 | + // Array.emptyObjectArray |
| 192 | + ref(defn.ArrayModule.companionModule).select("emptyObjectArray".toTermName).ensureApplied |
| 193 | + } else if (size <= Definitions.MaxTupleArity) { |
| 194 | + // DynamicTuple.productToArray(tup.asInstanceOf[Product]) |
| 195 | + ref(defn.DynamicTuple_productToArray).appliedTo(tup.asInstance(defn.ProductType)) |
| 196 | + } else { |
| 197 | + // tup.asInstanceOf[TupleXXL].elems |
| 198 | + tup.asInstance(defn.TupleXXLType).select(nme.elems) |
| 199 | + } |
| 200 | + case None => |
| 201 | + // DynamicTuple.dynamicToArray(tup) |
| 202 | + tree |
| 203 | + } |
| 204 | + } |
| 205 | + |
| 206 | + /** Create a TupleN (1 <= N < 23) from the elements */ |
| 207 | + private def knownTupleFromElements(tpes: List[Type], elements: List[Tree])(implicit ctx: Context) = { |
| 208 | + val size = elements.size |
| 209 | + assert(0 < size && size <= Definitions.MaxTupleArity) |
| 210 | + val tupleModule = defn.TupleType(size).classSymbol.companionModule |
| 211 | + ref(tupleModule).select(nme.apply).appliedToTypes(tpes).appliedToArgs(elements) |
| 212 | + } |
| 213 | + |
| 214 | + private def knownTupleFromIterator(size: Int, it: Tree)(implicit ctx: Context): Tree = { |
| 215 | + if (size == 0) { |
| 216 | + // Unit for empty tuple |
| 217 | + Literal(Constant(())) // TODO should this code be here? Or assert(size > specializedSize) |
| 218 | + } |
| 219 | + else if (size <= Definitions.MaxTupleArity) { |
| 220 | + // TupleN(it.next(), ..., it.next()) |
| 221 | + |
| 222 | + // TODO outline this code for the 22 alternatives (or less, may not need the smallest ones)? |
| 223 | + // This would yield smaller bytecode at the cost of an extra (easily JIT inlinable) call. |
| 224 | + // def dynamicTupleN(it: Iterator[Any]): TupleN[Any, ..., Any] = Tuple(it.next(), ..., it.next()) |
| 225 | + val tpes = List.fill(size)(defn.AnyType) |
| 226 | + val elements = (0 until size).map(_ => it.select(nme.next)).toList |
| 227 | + knownTupleFromElements(tpes, elements) |
| 228 | + } else { |
| 229 | + // TupleXXL.fromIterator(it) |
| 230 | + ref(defn.TupleXXL_fromIterator).appliedTo(it) |
| 231 | + } |
| 232 | + } |
| 233 | + |
| 234 | + private def tupleTypes(tp: Type)(implicit ctx: Context): Option[List[Type]] = { |
| 235 | + @tailrec def rec(tp: Type, acc: List[Type]): Option[List[Type]] = tp match { |
| 236 | + case tp: AppliedType if defn.PairClass == tp.classSymbol => rec(tp.args(1), tp.args(0) :: acc) |
| 237 | + case tp: AppliedType if defn.isTupleClass(tp.tycon.classSymbol) => Some(acc.reverse ::: tp.args) |
| 238 | + case tp if tp.classSymbol == defn.UnitClass => Some(acc.reverse) |
| 239 | + case _ => None |
| 240 | + } |
| 241 | + rec(tp.stripTypeVar, Nil) |
| 242 | + } |
| 243 | +} |
0 commit comments