From f039fa7fa2544998426764bd05ea8f18179eb0bd Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Tue, 1 Oct 2013 14:21:27 +0200 Subject: Added option -Yheartbeat MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit … which shows snapshot of the callstack of tracked operations at fixed intervals. --- src/dotty/tools/dotc/typer/Applications.scala | 54 ++++++++++++++------------- 1 file changed, 29 insertions(+), 25 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 3216e8b74..05008ac1a 100644 --- a/src/dotty/tools/dotc/typer/Applications.scala +++ b/src/dotty/tools/dotc/typer/Applications.scala @@ -5,6 +5,7 @@ package typer import core._ import ast.{Trees, untpd, tpd, TreeInfo} import util.Positions._ +import util.Stats.track import Trees.Untyped import Mode.ImplicitsEnabled import Contexts._ @@ -447,8 +448,9 @@ trait Applications extends Compatibility { self: Typer => def treeToArg(arg: Tree): Tree = arg } - def typedApply(app: untpd.Apply, fun: Tree, methRef: TermRef, args: List[Tree], resultType: Type)(implicit ctx: Context): Tree = + def typedApply(app: untpd.Apply, fun: Tree, methRef: TermRef, args: List[Tree], resultType: Type)(implicit ctx: Context): Tree = track("typedApply") { new ApplyToTyped(app, fun, methRef, args, resultType).result + } def typedApply(fun: Tree, methRef: TermRef, args: List[Tree], resultType: Type)(implicit ctx: Context): Tree = typedApply(untpd.Apply(untpd.TypedSplice(fun), args), fun, methRef, args, resultType) @@ -458,7 +460,7 @@ trait Applications extends Compatibility { self: Typer => typedUnApply(tree, pt) else { - def realApply(implicit ctx: Context): Tree = { + def realApply(implicit ctx: Context): Tree = track("realApply") { val proto = new FunProto(tree.args, pt, this) val fun1 = typedExpr(tree.fun, proto) methPart(fun1).tpe match { @@ -473,7 +475,7 @@ trait Applications extends Compatibility { self: Typer => case Select(qual, name) => tryEither { implicit ctx => val qual1 = adapt(qual, new SelectionProto(name, proto)) - if (qual1.tpe.isError || (qual1 eq qual)) qual1 + if (qual1.tpe.isError || (qual1 eq qual)) qual1 else typedApply( cpy.Apply(tree, @@ -494,7 +496,7 @@ trait Applications extends Compatibility { self: Typer => } } - def typedOpAssign: Tree = { + def typedOpAssign: Tree = track("typedOpAssign") { val Apply(Select(lhs, name), rhss) = tree val lhs1 = typedExpr(lhs) val lifted = new mutable.ListBuffer[Tree] @@ -517,7 +519,7 @@ trait Applications extends Compatibility { self: Typer => } } - def typedTypeApply(tree: untpd.TypeApply, pt: Type)(implicit ctx: Context): Tree = { + def typedTypeApply(tree: untpd.TypeApply, pt: Type)(implicit ctx: Context): Tree = track("typedTypeApply") { val typedFn = typedExpr(tree.fun, PolyProto(tree.args.length, pt)) val typedArgs = tree.args mapconserve (typedType(_)) val ownType = typedFn.tpe.widen match { @@ -531,7 +533,7 @@ trait Applications extends Compatibility { self: Typer => cpy.TypeApply(tree, typedFn, typedArgs).withType(ownType) } - def typedUnApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = { + def typedUnApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = track("typedUnApply") { val Apply(qual, args) = tree def unapplyArgs(unapplyResult: Type)(implicit ctx: Context): List[Type] = { @@ -662,7 +664,7 @@ trait Applications extends Compatibility { self: Typer => /** In a set of overloaded applicable alternatives, is `alt1` at least as good as * `alt2`? `alt1` and `alt2` are nonoverloaded references. */ - def isAsGood(alt1: TermRef, alt2: TermRef)(implicit ctx: Context): Boolean = { + def isAsGood(alt1: TermRef, alt2: TermRef)(implicit ctx: Context): Boolean = track("isAsGood") { /** Is class or module class `sym1` derived from class or module class `sym2`? */ def isDerived(sym1: Symbol, sym2: Symbol): Boolean = @@ -712,30 +714,32 @@ trait Applications extends Compatibility { self: Typer => else /* 1/9 */ winsType1 || /* 2/27 */ !winsType2 } - def narrowMostSpecific(alts: List[TermRef])(implicit ctx: Context): List[TermRef] = (alts: @unchecked) match { - case alt :: alts1 => - def winner(bestSoFar: TermRef, alts: List[TermRef]): TermRef = alts match { - case alt :: alts1 => - winner(if (isAsGood(alt, bestSoFar)) alt else bestSoFar, alts1) - case nil => - bestSoFar - } - val best = winner(alt, alts1) - def asGood(alts: List[TermRef]): List[TermRef] = alts match { - case alt :: alts1 => - if ((alt eq best) || !isAsGood(alt, best)) asGood(alts1) - else alt :: asGood(alts1) - case nil => - Nil - } - best :: asGood(alts1) + def narrowMostSpecific(alts: List[TermRef])(implicit ctx: Context): List[TermRef] = track("narrowMostSpecific") { + (alts: @unchecked) match { + case alt :: alts1 => + def winner(bestSoFar: TermRef, alts: List[TermRef]): TermRef = alts match { + case alt :: alts1 => + winner(if (isAsGood(alt, bestSoFar)) alt else bestSoFar, alts1) + case nil => + bestSoFar + } + val best = winner(alt, alts1) + def asGood(alts: List[TermRef]): List[TermRef] = alts match { + case alt :: alts1 => + if ((alt eq best) || !isAsGood(alt, best)) asGood(alts1) + else alt :: asGood(alts1) + case nil => + Nil + } + best :: asGood(alts1) + } } private lazy val dummyTree = untpd.Literal(Constant(null)) def dummyTreeOfType(tp: Type): Tree = dummyTree withTypeUnchecked tp /** Resolve overloaded alternative `alts`, given expected type `pt`. */ - def resolveOverloaded(alts: List[TermRef], pt: Type)(implicit ctx: Context): List[TermRef] = { + def resolveOverloaded(alts: List[TermRef], pt: Type)(implicit ctx: Context): List[TermRef] = track("resolveOverloaded") { def isDetermined(alts: List[TermRef]) = alts.isEmpty || alts.tail.isEmpty -- cgit v1.2.3