From bf59937182b66d12d01c11ff5dd27346ee4a9db4 Mon Sep 17 00:00:00 2001 From: Martin Odersky Date: Thu, 16 Jan 2014 22:00:16 +0100 Subject: Refactoring to avoid multiple overloaded traceIndent methods. --- src/dotty/tools/dotc/typer/Applications.scala | 4 ++-- src/dotty/tools/dotc/typer/Implicits.scala | 12 +++++++----- src/dotty/tools/dotc/typer/Typer.scala | 2 +- 3 files changed, 10 insertions(+), 8 deletions(-) (limited to 'src/dotty/tools/dotc/typer') diff --git a/src/dotty/tools/dotc/typer/Applications.scala b/src/dotty/tools/dotc/typer/Applications.scala index 6b73740bb..400c43e3c 100644 --- a/src/dotty/tools/dotc/typer/Applications.scala +++ b/src/dotty/tools/dotc/typer/Applications.scala @@ -741,7 +741,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 = track("isAsGood") { ctx.traceIndented(overload, i"isAsGood($alt1, $alt2)") { + def isAsGood(alt1: TermRef, alt2: TermRef)(implicit ctx: Context): Boolean = track("isAsGood") { ctx.traceIndented(i"isAsGood($alt1, $alt2)", overload) { assert(alt1 ne alt2) @@ -760,7 +760,7 @@ trait Applications extends Compatibility { self: Typer => * 2. `tp2` and `tp1` are method or poly types and `tp2` can be applied to the parameters of `tp1`. * 3. Neither `tp1` nor `tp2` are method or poly types and `tp1` is compatible with `tp2`. */ - def isAsSpecific(alt1: TermRef, tp1: Type, alt2: TermRef, tp2: Type): Boolean = ctx.traceIndented(overload, i"isAsSpecific $tp1 $tp2") { tp1 match { + def isAsSpecific(alt1: TermRef, tp1: Type, alt2: TermRef, tp2: Type): Boolean = ctx.traceIndented(i"isAsSpecific $tp1 $tp2", overload) { tp1 match { case tp1: PolyType => def bounds(tparamRefs: List[TypeRef]) = tp1.paramBounds map (_.substParams(tp1, tparamRefs)) val tparams = ctx.newTypeParams(alt1.symbol.owner, tp1.paramNames, EmptyFlags, bounds) diff --git a/src/dotty/tools/dotc/typer/Implicits.scala b/src/dotty/tools/dotc/typer/Implicits.scala index 5ab40d529..b5f7f0366 100644 --- a/src/dotty/tools/dotc/typer/Implicits.scala +++ b/src/dotty/tools/dotc/typer/Implicits.scala @@ -62,7 +62,7 @@ object Implicits { } /** The implicit references that are eligible for expected type `tp` */ - lazy val eligible: List[TermRef] = ctx.traceIndented(implicits, i"eligible($tp), companions = ${companionRefs.toList}%, %", show = true)(filterMatching(tp)) + lazy val eligible: List[TermRef] = ctx.traceIndented(i"eligible($tp), companions = ${companionRefs.toList}%, %", implicits, show = true)(filterMatching(tp)) override def toString = i"OfTypeImplicits($tp), companions = ${companionRefs.toList}%, %; refs = $refs%, %." @@ -215,7 +215,7 @@ trait ImplicitRunInfo { self: RunInfo => // todo: compute implicits directly, without going via companionRefs? def collectCompanions(tp: Type): TermRefSet = track("computeImplicicScope") { - ctx.traceIndented(implicits, i"collectCompanions($tp)") { + ctx.traceIndented(i"collectCompanions($tp)", implicits) { val comps = new TermRefSet tp match { case tp: NamedType => @@ -295,7 +295,7 @@ trait Implicits { self: Typer => * !!! todo: catch potential cycles */ def inferImplicit(pt: Type, argument: Tree, pos: Position)(implicit ctx: Context): SearchResult = track("inferImplicit") { - ctx.traceIndented(implicits, s"search implicit ${pt.show}, arg = ${argument.show}: ${argument.tpe.show}, constraint = ${ctx.typerState.constraint.show}", show = true) { + ctx.traceIndented(s"search implicit ${pt.show}, arg = ${argument.show}: ${argument.tpe.show}, constraint = ${ctx.typerState.constraint.show}", implicits, show = true) { assert(!pt.isInstanceOf[ExprType]) val isearch = if (ctx.settings.explaintypes.value) new ExplainedImplicitSearch(pt, argument, pos) @@ -349,7 +349,7 @@ trait Implicits { self: Typer => def searchImplicits(eligible: List[TermRef], contextual: Boolean): SearchResult = { /** Try to typecheck an implicit reference */ - def typedImplicit(ref: TermRef)(implicit ctx: Context): SearchResult = track("typedImplicit") { ctx.traceIndented(implicits, i"typed implicit $ref, pt = $pt, implicitsEnabled == ${ctx.mode is ImplicitsEnabled}", show = true) { + def typedImplicit(ref: TermRef)(implicit ctx: Context): SearchResult = track("typedImplicit") { ctx.traceIndented(i"typed implicit $ref, pt = $pt, implicitsEnabled == ${ctx.mode is ImplicitsEnabled}", implicits, show = true) { var generated: Tree = Ident(ref).withPos(pos) if (!argument.isEmpty) generated = typedUnadapted( @@ -544,4 +544,6 @@ class TermRefSet(implicit ctx: Context) extends mutable.Traversable[TermRef] { for (sym <- elems.keysIterator) for (pre <- elems(sym)) f(TermRef(pre, sym)) -} \ No newline at end of file +} + +object EmptyTermRefSet extends TermRefSet()(NoContext) diff --git a/src/dotty/tools/dotc/typer/Typer.scala b/src/dotty/tools/dotc/typer/Typer.scala index d35e5fa93..c1e771f16 100644 --- a/src/dotty/tools/dotc/typer/Typer.scala +++ b/src/dotty/tools/dotc/typer/Typer.scala @@ -663,7 +663,7 @@ class Typer extends Namer with Applications with Implicits { * which appear with variances +1 and -1 (in different * places) be considered as well? */ - val gadtSyms: Set[Symbol] = ctx.traceIndented(gadts, i"GADT syms of $selType") { + val gadtSyms: Set[Symbol] = ctx.traceIndented(i"GADT syms of $selType", gadts) { val accu = new TypeAccumulator[Set[Symbol]] { def apply(tsyms: Set[Symbol], t: Type): Set[Symbol] = { val tsyms1 = t match { -- cgit v1.2.3