From 60b3469ac70052b762cc7bf0d36bf2ec37e8e6dc Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Sat, 27 Jul 2013 19:48:30 +0200 Subject: Redesign of trees. 1) Trees are now contravariant. 2) All creation ops, transformers, copiers are pushed into Instance. 3) Still to do: integrate TreeMappers and tpd.TreeTransformers. --- src/dotty/tools/dotc/typer/Applications.scala | 65 +++++++++++++-------------- 1 file changed, 32 insertions(+), 33 deletions(-) (limited to 'src/dotty/tools/dotc/typer/Applications.scala') diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala index 3ce735c12..6424b96e4 100644 --- a/src/dotty/tools/dotc/typer/Applications.scala +++ b/src/dotty/tools/dotc/typer/Applications.scala @@ -27,7 +27,7 @@ import language.implicitConversions object Applications { - import tpd._ + import tpd.{ cpy => _, _ } private val isNamedArg = (arg: Any) => arg.isInstanceOf[Trees.NamedArg[_]] def hasNamedArg(args: List[Any]) = args exists isNamedArg @@ -44,10 +44,9 @@ object Applications { * 3. there is an implicit conversion from `tp` to `pt`. */ def isCompatible(tp: Type, pt: Type)(implicit ctx: Context): Boolean = ( - tp <:< pt - || pt.typeSymbol == defn.ByNameParamClass && tp <:< pt.typeArgs.head - || viewExists(tp, pt) - ) + tp <:< pt + || pt.typeSymbol == defn.ByNameParamClass && tp <:< pt.typeArgs.head + || viewExists(tp, pt)) } /** The normalized form of a type @@ -82,15 +81,15 @@ object Applications { import Applications._ -trait Applications extends Compatibility{ self: Typer => +trait Applications extends Compatibility { self: Typer => import Applications._ - import tpd._ + import tpd.{ cpy => _, _ } + import untpd.cpy private def state(implicit ctx: Context) = ctx.typerState - /** - * @param Arg the type of arguments, could be tpd.Tree, untpd.Tree, or Type + /** @param Arg the type of arguments, could be tpd.Tree, untpd.Tree, or Type * @param methRef the reference to the method of the application * @param funType the type of the function part of the application * @param args the arguments of the application @@ -206,7 +205,7 @@ trait Applications extends Compatibility{ self: Typer => args match { case (arg @ NamedArg(aname, _)) :: args1 => if (namedToArg contains aname) - emptyTree[T]() :: recur(pnames1, args) + genericEmptyTree :: recur(pnames1, args) else { badNamedArg(arg) recur(pnames1, args1) @@ -222,8 +221,7 @@ trait Applications extends Compatibility{ self: Typer => val (namedArgs, otherArgs) = args partition isNamedArg namedArgs foreach badNamedArg otherArgs - } - else args + } else args } recur(methodType.paramNames, args) @@ -289,14 +287,14 @@ trait Applications extends Compatibility{ self: Typer => } def tryDefault(n: Int, args1: List[Arg]): Unit = { - findDefaultGetter(n + TreeInfo.numArgs(normalizedFun)) match { + findDefaultGetter(n + numArgs(normalizedFun)) match { case dref: NamedType => liftFun() addTyped(treeToArg(spliceMeth(Ident(dref), normalizedFun)), formal) matchArgs(args1, formals1, n + 1) case _ => missingArg(n) - } + } } if (formal.isRepeatedParam) @@ -377,7 +375,7 @@ trait Applications extends Compatibility{ self: Typer => */ trait TreeApplication[T >: Untyped] extends Application[Trees.Tree[T]] { type TypeArg = Tree - def isVarArg(arg: Trees.Tree[T]): Boolean = TreeInfo.isWildcardStarArg(arg) + def isVarArg(arg: Trees.Tree[T]): Boolean = isWildcardStarArg(arg) } /** Subclass of Application for applicability tests with trees as arguments. */ @@ -471,7 +469,7 @@ trait Applications extends Compatibility{ self: Typer => typedArgs = args.asInstanceOf[List[Tree]] methodType.instantiate(typedArgs map (_.tpe)) } - val app1 = app.withType(ownType).derivedApply(normalizedFun, typedArgs) + val app1 = cpy.Apply(app, normalizedFun, typedArgs).withType(ownType) if (liftedDefs != null && liftedDefs.nonEmpty) Block(liftedDefs.toList, app1) else app1 } @@ -495,7 +493,7 @@ trait Applications extends Compatibility{ self: Typer => new ApplyToTyped(app, fun, methRef, args, resultType).result def typedApply(fun: Tree, methRef: TermRef, args: List[Tree], resultType: Type)(implicit ctx: Context): Tree = - typedApply(Trees.Apply(untpd.TypedSplice(fun), Nil), fun, methRef, args, resultType) + typedApply(untpd.Apply(untpd.TypedSplice(fun), Nil), fun, methRef, args, resultType) def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = { if (ctx.mode is Mode.Pattern) @@ -505,7 +503,7 @@ trait Applications extends Compatibility{ self: Typer => def realApply(implicit ctx: Context) = { val proto = new FunProtoType(tree.args, pt, this) val fun1 = typedExpr(tree.fun, proto) - TreeInfo.methPart(fun1).tpe match { + methPart(fun1).tpe match { case funRef: TermRef => val app = if (proto.argsAreTyped) new ApplyToTyped(tree, fun1, funRef, proto.typedArgs, pt) @@ -525,12 +523,12 @@ trait Applications extends Compatibility{ self: Typer => val lhs1 = typedExpr(lhs) val lifted = new mutable.ListBuffer[Tree] val lhs2 = untpd.TypedSplice(liftApp(lifted, lhs1)) - val assign = Trees.Assign(lhs2, Trees.Apply(Trees.Select(lhs2, name.init), rhss)) + val assign = untpd.Assign(lhs2, untpd.Apply(untpd.Select(lhs2, name.init), rhss)) typed(assign) } realApply - if (TreeInfo.isOpAssign(tree)) + if (untpd.isOpAssign(tree)) tryEither { implicit ctx => realApply } { failed => @@ -555,7 +553,7 @@ trait Applications extends Compatibility{ self: Typer => ctx.error(s"${err.exprStr(typedFn)} does not take type parameters", tree.pos) ErrorType } - tree.withType(ownType).derivedTypeApply(typedFn, typedArgs) + cpy.TypeApply(tree, typedFn, typedArgs).withType(ownType) } def typedUnApply(qual: untpd.Tree, args: List[untpd.Tree], tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = { @@ -586,7 +584,7 @@ trait Applications extends Compatibility{ self: Typer => ctx.error(s"${unapplyResult.show} is not a valid result type of an unapply method of an extractor", tree.pos) Nil } - } + } recur(unapplyResult) } @@ -595,13 +593,14 @@ trait Applications extends Compatibility{ self: Typer => val dummyArg = untpd.TypedSplice(dummyTreeOfType(WildcardType)) val unappProto = FunProtoType(dummyArg :: Nil, pt, this) tryEither { - implicit ctx => typedExpr(Trees.Select(qual, nme.unapply), unappProto) + implicit ctx => typedExpr(untpd.Select(qual, nme.unapply), unappProto) } { - s => tryEither { - implicit ctx => typedExpr(Trees.Select(qual, nme.unapplySeq), unappProto) // for backwards compatibility; will be dropped - } { - _ => errorTree(s.value, s"${qual.show} cannot be used as an extractor in a pattern because it lacks an unapply or unapplySeq method") - } + s => + tryEither { + implicit ctx => typedExpr(untpd.Select(qual, nme.unapplySeq), unappProto) // for backwards compatibility; will be dropped + } { + _ => errorTree(s.value, s"${qual.show} cannot be used as an extractor in a pattern because it lacks an unapply or unapplySeq method") + } } } fn.tpe.widen match { @@ -610,7 +609,7 @@ trait Applications extends Compatibility{ self: Typer => ownType <:< pt // done for registering the constraints; error message would come later var argTypes = unapplyArgs(ownType) val bunchedArgs = argTypes match { - case argType :: Nil if argType.isRepeatedParam => Trees.SeqLiteral(args) :: Nil + case argType :: Nil if argType.isRepeatedParam => untpd.SeqLiteral(args) :: Nil case _ => args } if (argTypes.length != bunchedArgs.length) { @@ -619,7 +618,7 @@ trait Applications extends Compatibility{ self: Typer => List.fill(argTypes.length - args.length)(WildcardType) } val typedArgs = (bunchedArgs, argTypes).zipped map (typed(_, _)) - Trees.UnApply(fn, typedArgs).withPos(tree.pos).withType(ownType) + untpd.UnApply(fn, typedArgs).withPos(tree.pos).withType(ownType) case et: ErrorType => tree.withType(ErrorType) } @@ -713,7 +712,7 @@ trait Applications extends Compatibility{ self: Typer => best :: asGood(alts1) } - private val dummyTree = Trees.Literal(Constant(null)) + private val dummyTree = untpd.Literal(Constant(null)) def dummyTreeOfType(tp: Type): Tree = dummyTree withType tp /** Resolve overloaded alternative `alts`, given expected type `pt`. */ @@ -735,7 +734,7 @@ trait Applications extends Compatibility{ self: Typer => def treeShape(tree: untpd.Tree): Tree = tree match { case NamedArg(name, arg) => val argShape = treeShape(arg) - tree.withType(argShape.tpe).derivedNamedArg(name, argShape) + cpy.NamedArg(tree, name, argShape).withType(argShape.tpe) case _ => dummyTreeOfType(typeShape(tree)) } @@ -783,7 +782,7 @@ trait Applications extends Compatibility{ self: Typer => } case pt @ PolyProtoType(nargs, _) => - alts filter ( alt => alt.widen match { + alts filter (alt => alt.widen match { case PolyType(pnames) if pnames.length == nargs => true case _ => false }) -- cgit v1.2.3