From 4b32ec471bafe988b64563aaabf2d273220a8644 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Sat, 10 Aug 2013 12:32:04 +0200 Subject: Added typing of Alternatives. Also changed some maps to mapconserves to avoid unnecessary tree copying. --- src/dotty/tools/dotc/typer/Applications.scala | 13 +++++++------ src/dotty/tools/dotc/typer/Typer.scala | 19 ++++++++++++------- 2 files changed, 19 insertions(+), 13 deletions(-) (limited to 'src/dotty/tools/dotc') diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala index 242acc43b..334e21ccb 100644 --- a/src/dotty/tools/dotc/typer/Applications.scala +++ b/src/dotty/tools/dotc/typer/Applications.scala @@ -467,7 +467,7 @@ trait Applications extends Compatibility { self: Typer => } if (sameSeq(typedArgs, args)) // trick to cut down on tree copying typedArgs = args.asInstanceOf[List[Tree]] - methodType.instantiate(typedArgs map (_.tpe)) + methodType.instantiate(typedArgs.tpes) } val app1 = cpy.Apply(app, normalizedFun, typedArgs).withType(ownType) if (liftedDefs != null && liftedDefs.nonEmpty) Block(liftedDefs.toList, app1) @@ -497,7 +497,7 @@ trait Applications extends Compatibility { self: Typer => def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = { if (ctx.mode is Mode.Pattern) - typedUnApply(tree.fun, tree.args, tree, pt) + typedUnApply(tree, pt) else { def realApply(implicit ctx: Context) = { @@ -544,11 +544,11 @@ trait Applications extends Compatibility { self: Typer => def typedTypeApply(tree: untpd.TypeApply, pt: Type)(implicit ctx: Context): Tree = { val typedFn = typedExpr(tree.fun, PolyProtoType(tree.args.length, pt)) - val typedArgs = tree.args map (typedType(_)) + val typedArgs = tree.args mapconserve (typedType(_)) val ownType = typedFn.tpe.widen match { case pt: PolyType => checkBounds(typedArgs, pt, tree.pos) - pt.resultType.substParams(pt, typedArgs map (_.tpe)) + pt.resultType.substParams(pt, typedArgs.tpes) case _ => ctx.error(s"${err.exprStr(typedFn)} does not take type parameters", tree.pos) ErrorType @@ -556,7 +556,8 @@ trait Applications extends Compatibility { self: Typer => 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 = { + def typedUnApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = { + val Apply(qual, args) = tree def unapplyArgs(unapplyResult: Type)(implicit ctx: Context): List[Type] = { def recur(tp: Type): List[Type] = { @@ -646,7 +647,7 @@ trait Applications extends Compatibility { self: Typer => else Typed(result, TypeTree(ownType)) case tp => val unapplyErr = if (tp.isError) unapply else notAnExtractor(unapply) - val typedArgsErr = args map (typed(_, defn.AnyType)) + val typedArgsErr = args mapconserve (typed(_, defn.AnyType)) cpy.UnApply(tree, unapplyErr, typedArgsErr) withType ErrorType } } diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala index 0869aff43..e81672eda 100644 --- a/src/dotty/tools/dotc/typer/Typer.scala +++ b/src/dotty/tools/dotc/typer/Typer.scala @@ -438,7 +438,7 @@ class Typer extends Namer with Applications with Implicits { } def typedClosure(tree: untpd.Closure, pt: Type)(implicit ctx: Context) = { - val env1 = tree.env map (typed(_)) + val env1 = tree.env mapconserve (typed(_)) val meth1 = typed(tree.meth) val ownType = meth1.tpe.widen match { case mt: MethodType if !mt.isDependent => @@ -492,7 +492,7 @@ class Typer extends Namer with Applications with Implicits { (doCase /: gadtSyms) ((op, tsym) => tsym.withGADTFlexType(op)) () } - val cases1 = tree.cases map typedCase + val cases1 = tree.cases mapconserve typedCase cpy.Match(tree, sel1, cases1).withType(ctx.lub(cases1.tpes)) } @@ -540,7 +540,7 @@ class Typer extends Namer with Applications with Implicits { def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(implicit ctx: Context): SeqLiteral = { val proto1 = pt.elemType orElse WildcardType - val elems1 = tree.elems map (typed(_, proto1)) + val elems1 = tree.elems mapconserve (typed(_, proto1)) cpy.SeqLiteral(tree, elems1) withType ctx.lub(elems1.tpes) } @@ -606,7 +606,7 @@ class Typer extends Namer with Applications with Implicits { def typedAppliedTypeTree(tree: untpd.AppliedTypeTree)(implicit ctx: Context): AppliedTypeTree = { val tpt1 = typed(tree.tpt) - val args1 = tree.args map (typed(_)) + val args1 = tree.args mapconserve (typed(_)) val tparams = tpt1.tpe.typeParams if (args1.length != tparams.length) ctx.error(s"wrong number of type arguments for ${tpt1.tpe.show}, should be ${tparams.length}") @@ -628,6 +628,11 @@ class Typer extends Namer with Applications with Implicits { cpy.Bind(tree, tree.name, body1) withType TermRef.withSym(NoPrefix, sym) } + def typedAlternative(tree: untpd.Alternative, pt: Type)(implicit ctx: Context): Alternative = { + val trees1 = tree.trees mapconserve (typed(_, pt)) + cpy.Alternative(tree, trees1) withType ctx.lub(trees1.tpes) + } + def typedModifiers(mods: untpd.Modifiers)(implicit ctx: Context): Modifiers = { val annotations1 = mods.annotations mapconserve typedAnnotation if (annotations1 eq mods.annotations) mods.asInstanceOf[Modifiers] @@ -642,15 +647,15 @@ class Typer extends Namer with Applications with Implicits { val mods1 = typedModifiers(mods) val tpt1 = typedType(tpt) val rhs1 = typedExpr(rhs, tpt1.tpe) - val pt = if (sym.exists) sym.symRef else NoType - cpy.ValDef(vdef, mods1, name, tpt1, rhs1).withType(pt) + val refType = if (sym.exists) sym.symRef else NoType + cpy.ValDef(vdef, mods1, name, tpt1, rhs1).withType(refType) } def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context) = { val DefDef(mods, name, tparams, vparamss, tpt, rhs) = ddef val mods1 = typedModifiers(mods) val tparams1 = tparams mapconserve (typed(_).asInstanceOf[TypeDef]) - val vparamss1 = vparamss.mapconserve(_ mapconserve (typed(_).asInstanceOf[ValDef])) + val vparamss1 = vparamss mapconserve(_ mapconserve (typed(_).asInstanceOf[ValDef])) val tpt1 = typedType(tpt) val rhs1 = typedExpr(rhs, tpt1.tpe) cpy.DefDef(ddef, mods1, name, tparams1, vparamss1, tpt1, rhs1).withType(sym.symRef) -- cgit v1.2.3