diff --git a/src/dotty/tools/dotc/core/Phases.scala b/src/dotty/tools/dotc/core/Phases.scala index 348789e148af..8476ae601550 100644 --- a/src/dotty/tools/dotc/core/Phases.scala +++ b/src/dotty/tools/dotc/core/Phases.scala @@ -220,6 +220,7 @@ object Phases { private var myErasedTypes = false private var myFlatClasses = false private var myRefChecked = false + private var mySymbolicRefs = false /** The sequence position of this phase in the given context where 0 * is reserved for NoPhase and the first real phase is at position 1. @@ -231,18 +232,20 @@ object Phases { def start = myPeriod.firstPhaseId def end = myPeriod.lastPhaseId - final def erasedTypes = myErasedTypes - final def flatClasses = myFlatClasses - final def refChecked = myRefChecked + final def erasedTypes = myErasedTypes // Phase is after erasure + final def flatClasses = myFlatClasses // Phase is after flatten + final def refChecked = myRefChecked // Phase is after RefChecks + final def symbolicRefs = mySymbolicRefs // Phase is after ResolveSuper, newly generated TermRefs should be symbolic protected[Phases] def init(base: ContextBase, start: Int, end:Int): Unit = { if (start >= FirstPhaseId) assert(myPeriod == Periods.InvalidPeriod, s"phase $this has already been used once; cannot be reused") myBase = base myPeriod = Period(start, end) - myErasedTypes = prev.getClass == classOf[Erasure] || prev.erasedTypes - myFlatClasses = prev.getClass == classOf[Flatten] || prev.flatClasses - myRefChecked = prev.getClass == classOf[RefChecks] || prev.refChecked + myErasedTypes = prev.getClass == classOf[Erasure] || prev.erasedTypes + myFlatClasses = prev.getClass == classOf[Flatten] || prev.flatClasses + myRefChecked = prev.getClass == classOf[RefChecks] || prev.refChecked + mySymbolicRefs = prev.getClass == classOf[ResolveSuper] || prev.symbolicRefs } protected[Phases] def init(base: ContextBase, id: Int): Unit = init(base, id, id) diff --git a/src/dotty/tools/dotc/core/Types.scala b/src/dotty/tools/dotc/core/Types.scala index feee05d868e6..017b7cadcef3 100644 --- a/src/dotty/tools/dotc/core/Types.scala +++ b/src/dotty/tools/dotc/core/Types.scala @@ -1542,6 +1542,8 @@ object Types { object TermRef { + private def symbolicRefs(implicit ctx: Context) = ctx.phase.symbolicRefs + /** Create term ref with given name, without specifying a signature. * Its meaning is the (potentially multi-) denotation of the member(s) * of prefix with given name. @@ -1562,7 +1564,7 @@ object Types { * signature, if denotation is not yet completed. */ def apply(prefix: Type, name: TermName, denot: Denotation)(implicit ctx: Context): TermRef = { - if ((prefix eq NoPrefix) || denot.symbol.isFresh || ctx.erasedTypes) + if ((prefix eq NoPrefix) || denot.symbol.isFresh || symbolicRefs) apply(prefix, denot.symbol.asTerm) else denot match { case denot: SymDenotation if denot.isCompleted => withSig(prefix, name, denot.signature) @@ -1584,7 +1586,7 @@ object Types { * (2) The name in the term ref need not be the same as the name of the Symbol. */ def withSymAndName(prefix: Type, sym: TermSymbol, name: TermName)(implicit ctx: Context): TermRef = - if ((prefix eq NoPrefix) || sym.isFresh || ctx.erasedTypes) + if ((prefix eq NoPrefix) || sym.isFresh || symbolicRefs) withFixedSym(prefix, name, sym) else if (sym.defRunId != NoRunId && sym.isCompleted) withSig(prefix, name, sym.signature) withSym (sym, sym.signature) @@ -1595,7 +1597,7 @@ object Types { * (which must be completed). */ def withSig(prefix: Type, sym: TermSymbol)(implicit ctx: Context): TermRef = - if ((prefix eq NoPrefix) || sym.isFresh || ctx.erasedTypes) withFixedSym(prefix, sym.name, sym) + if ((prefix eq NoPrefix) || sym.isFresh || symbolicRefs) withFixedSym(prefix, sym.name, sym) else withSig(prefix, sym.name, sym.signature).withSym(sym, sym.signature) /** Create a term ref with given prefix, name and signature */ @@ -1604,7 +1606,7 @@ object Types { /** Create a term ref with given prefix, name, signature, and initial denotation */ def withSigAndDenot(prefix: Type, name: TermName, sig: Signature, denot: Denotation)(implicit ctx: Context): TermRef = { - if ((prefix eq NoPrefix) || denot.symbol.isFresh || ctx.erasedTypes) + if ((prefix eq NoPrefix) || denot.symbol.isFresh || symbolicRefs) withFixedSym(prefix, denot.symbol.asTerm.name, denot.symbol.asTerm) else withSig(prefix, name, sig) diff --git a/src/dotty/tools/dotc/typer/RefChecks.scala b/src/dotty/tools/dotc/typer/RefChecks.scala index 6995076c5cbe..bf0f75c96029 100644 --- a/src/dotty/tools/dotc/typer/RefChecks.scala +++ b/src/dotty/tools/dotc/typer/RefChecks.scala @@ -222,8 +222,10 @@ object RefChecks { } /* Is the intersection between given two lists of overridden symbols empty? */ - def intersectionIsEmpty(syms1: Iterator[Symbol], syms2: Iterator[Symbol]) = - !(syms1 exists (syms2 contains _)) + def intersectionIsEmpty(syms1: Iterator[Symbol], syms2: Iterator[Symbol]) = { + val set2 = syms2.toSet + !(syms1 exists (set2 contains _)) + } // o: public | protected | package-protected (aka java's default access) // ^-may be overridden by member with access privileges-v diff --git a/test/dotc/tests.scala b/test/dotc/tests.scala index 1c437e833018..064a70250dfc 100644 --- a/test/dotc/tests.scala +++ b/test/dotc/tests.scala @@ -112,8 +112,7 @@ class tests extends CompilerTest { @Test def dotc_config = compileDir(dotcDir + "tools/dotc/config", twice) @Test def dotc_core = compileDir(dotcDir + "tools/dotc/core", twice)(allowDeepSubtypes) @Test def dotc_core_pickling = compileDir(dotcDir + "tools/dotc/core/pickling", twice)(allowDeepSubtypes) - // @Test def dotc_transform = compileDir(dotcDir + "tools/dotc/transform", twice)(allowDeepSubtypes) - // @odersky causes race error in ResolveSuper + @Test def dotc_transform = compileDir(dotcDir + "tools/dotc/transform", twice)(allowDeepSubtypes) @Test def dotc_parsing = compileDir(dotcDir + "tools/dotc/parsing", twice) @Test def dotc_printing = compileDir(dotcDir + "tools/dotc/printing", twice)