diff --git a/.gitignore b/.gitignore
index b8e3c9e0f96e..818b7e549e0f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -73,3 +73,4 @@ compiler/after-pickling.txt
 *.dotty-ide-version
 
 *.decompiled.out
+bench/compile.txt
diff --git a/compiler/src/dotty/tools/backend/jvm/CollectEntryPoints.scala b/compiler/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
index 41b7e549d2f5..856b3ec5d2b3 100644
--- a/compiler/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
+++ b/compiler/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
@@ -67,7 +67,7 @@ object CollectEntryPoints{
     def fail(msg: String, pos: Position = sym.pos) = {
       ctx.warning(          sym.name +
         s" has a main method with parameter type Array[String], but ${toDenot(sym).fullName} will not be a runnable program.\n  Reason: $msg",
-        sourcePos(sym.pos)
+        sym.pos
         // TODO: make this next claim true, if possible
         //   by generating valid main methods as static in module classes
         //   not sure what the jvm allows here
diff --git a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
index 008c5aab184c..d42da65d7898 100644
--- a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
+++ b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -154,9 +154,9 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   lazy val Predef_classOf: Symbol = defn.ScalaPredefModule.requiredMethod(nme.classOf)
 
   lazy val AnnotationRetentionAttr = ctx.requiredClass("java.lang.annotation.Retention")
-  lazy val AnnotationRetentionSourceAttr = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("SOURCE")
-  lazy val AnnotationRetentionClassAttr = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("CLASS")
-  lazy val AnnotationRetentionRuntimeAttr = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("RUNTIME")
+  lazy val AnnotationRetentionSourceAttr = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("SOURCE".toTermName)
+  lazy val AnnotationRetentionClassAttr = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("CLASS".toTermName)
+  lazy val AnnotationRetentionRuntimeAttr = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("RUNTIME".toTermName)
   lazy val JavaAnnotationClass = ctx.requiredClass("java.lang.annotation.Annotation")
 
   def boxMethods: Map[Symbol, Symbol] = defn.ScalaValueClasses().map{x => // @darkdimius Are you sure this should be a def?
@@ -366,7 +366,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   def getAnnotPickle(jclassName: String, sym: Symbol): Option[Annotation] = None
 
 
-  def getRequiredClass(fullname: String): Symbol = ctx.requiredClass(fullname.toTermName)
+  def getRequiredClass(fullname: String): Symbol = ctx.requiredClass(fullname)
 
   def getClassIfDefined(fullname: String): Symbol = NoSymbol // used only for android. todo: implement
 
@@ -376,12 +376,12 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   }
 
   def requiredClass[T](implicit evidence: ClassTag[T]): Symbol =
-    ctx.requiredClass(erasureString(evidence.runtimeClass).toTermName)
+    ctx.requiredClass(erasureString(evidence.runtimeClass))
 
   def requiredModule[T](implicit evidence: ClassTag[T]): Symbol = {
     val moduleName = erasureString(evidence.runtimeClass)
     val className = if (moduleName.endsWith("$")) moduleName.dropRight(1)  else moduleName
-    ctx.requiredModule(className.toTermName)
+    ctx.requiredModule(className)
   }
 
 
@@ -498,7 +498,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     // unrelated change.
        ctx.base.settings.YnoGenericSig.value
     || sym.is(Flags.Artifact)
-    || sym.is(Flags.allOf(Flags.Method, Flags.Lifted))
+    || sym.isBoth(Flags.Method, and = Flags.Lifted)
     || sym.is(Flags.Bridge)
   )
 
@@ -679,7 +679,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def isConstructor: Boolean = toDenot(sym).isConstructor
     def isAnonymousFunction: Boolean = toDenot(sym).isAnonymousFunction
     def isMethod: Boolean = sym is Flags.Method
-    def isPublic: Boolean =  sym.flags.is(Flags.EmptyFlags, Flags.Private | Flags.Protected)
+    def isPublic: Boolean =  sym.flags.is(Flags.EmptyFlags, butNot=Flags.Private | Flags.Protected)
     def isSynthetic: Boolean = sym is Flags.Synthetic
     def isPackageClass: Boolean = sym is Flags.PackageClass
     def isModuleClass: Boolean = sym is Flags.ModuleClass
@@ -716,7 +716,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def isDeprecated: Boolean = false
     def isMutable: Boolean = sym is Flags.Mutable
     def hasAbstractFlag: Boolean =
-      (sym is Flags.Abstract) || (sym is Flags.JavaInterface) || (sym is Flags.Trait)
+      (sym is Flags.Abstract) || (sym is Flags.Trait)
     def hasModuleFlag: Boolean = sym is Flags.Module
     def isSynchronized: Boolean = sym is Flags.Synchronized
     def isNonBottomSubClass(other: Symbol): Boolean = sym.derivesFrom(other)
@@ -808,26 +808,28 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
       else Nil
 
     def annotations: List[Annotation] = toDenot(sym).annotations
-    def companionModuleMembers: List[Symbol] =  {
+
+    def companionModuleMembers: List[Symbol] = {
       // phase travel to exitingPickler: this makes sure that memberClassesOf only sees member classes,
       // not local classes of the companion module (E in the exmaple) that were lifted by lambdalift.
       if (linkedClass.isTopLevelModuleClass) /*exitingPickler*/ linkedClass.memberClasses
       else Nil
     }
+
     def fieldSymbols: List[Symbol] = {
       toDenot(sym).info.decls.filter(p => p.isTerm && !p.is(Flags.Method))
     }
+
     def methodSymbols: List[Symbol] =
       for (f <- toDenot(sym).info.decls.toList if f.isMethod && f.isTerm && !f.isModule) yield f
-    def serialVUID: Option[Long] = None
 
+    def serialVUID: Option[Long] = None
 
-    def freshLocal(cunit: CompilationUnit, name: String, tpe: Type, pos: Position, flags: Flags): Symbol = {
-      ctx.newSymbol(sym, name.toTermName, FlagSet(flags), tpe, NoSymbol, pos)
-    }
+    def freshLocal(cunit: CompilationUnit, name: String, tpe: Type, pos: Position, flags: Flags): Symbol =
+      ctx.newSymbol(sym, name.toTermName, FlagSet(flags), tpe, NoSymbol, pos.toCoord)
 
-    def getter(clz: Symbol): Symbol = decorateSymbol(sym).getter
-    def setter(clz: Symbol): Symbol = decorateSymbol(sym).setter
+    def getter(clz: Symbol): Symbol = new SymUtilsOps(sym).getter
+    def setter(clz: Symbol): Symbol = new SymUtilsOps(sym).setter
 
     def moduleSuffix: String = "" // todo: validate that names already have $ suffix
     def outputDirectory: AbstractFile = DottyBackendInterface.this.outputDirectory
@@ -840,7 +842,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
      * Redundant interfaces are removed unless there is a super call to them.
      */
     def superInterfaces: List[Symbol] = {
-      val directlyInheritedTraits = decorateSymbol(sym).directlyInheritedTraits
+      val directlyInheritedTraits = new SymUtilsOps(sym).directlyInheritedTraits
       val directlyInheritedTraitsSet = directlyInheritedTraits.toSet
       val allBaseClasses = directlyInheritedTraits.iterator.flatMap(_.symbol.asClass.baseClasses.drop(1)).toSet
       val superCalls = superCallsMap.getOrElse(sym, Set.empty)
@@ -1193,8 +1195,8 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
         val arity = field.meth.tpe.widenDealias.paramTypes.size - _1.size
         val returnsUnit = field.meth.tpe.widenDealias.resultType.classSymbol == UnitClass
         if (returnsUnit)
-          ctx.requiredClass(("scala.compat.java8.JProcedure" + arity).toTermName)
-        else ctx.requiredClass(("scala.compat.java8.JFunction" + arity).toTermName)
+          ctx.requiredClass("scala.compat.java8.JProcedure" + arity)
+        else ctx.requiredClass("scala.compat.java8.JFunction" + arity)
       }
     }
   }
diff --git a/compiler/src/dotty/tools/dotc/Run.scala b/compiler/src/dotty/tools/dotc/Run.scala
index 925890d4ff4c..68f449d32c80 100644
--- a/compiler/src/dotty/tools/dotc/Run.scala
+++ b/compiler/src/dotty/tools/dotc/Run.scala
@@ -43,7 +43,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    */
   protected[this] def rootContext(implicit ctx: Context): Context = {
     ctx.initialize()(ctx)
-    ctx.setPhasePlan(comp.phases)
+    ctx.base.setPhasePlan(comp.phases)
     val rootScope = new MutableScope
     val bootstrap = ctx.fresh
       .setPeriod(Period(comp.nextRunId, FirstPhaseId))
@@ -147,7 +147,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   }
 
   protected def compileUnits()(implicit ctx: Context) = Stats.maybeMonitored {
-    ctx.checkSingleThreaded()
+    ctx.base.checkSingleThreaded()
     compiling = true
 
     // If testing pickler, make sure to stop after pickling phase:
@@ -155,15 +155,15 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
       if (ctx.settings.YtestPickler.value) List("pickler")
       else ctx.settings.YstopAfter.value
 
-    val phases = ctx.squashPhases(ctx.phasePlan,
+    val phases = ctx.base.squashPhases(ctx.base.phasePlan,
       ctx.settings.Yskip.value, ctx.settings.YstopBefore.value, stopAfter, ctx.settings.Ycheck.value)
-    ctx.usePhases(phases)
+    ctx.base.usePhases(phases)
 
     def runPhases(implicit ctx: Context) = {
       var lastPrintedTree: PrintedTree = NoPrintedTree
       val profiler = ctx.profiler
 
-      for (phase <- ctx.allPhases)
+      for (phase <- ctx.base.allPhases)
         if (phase.isRunnable)
           Stats.trackTime(s"$phase ms ") {
             val start = System.currentTimeMillis
@@ -222,7 +222,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   private def printTree(last: PrintedTree)(implicit ctx: Context): PrintedTree = {
     val unit = ctx.compilationUnit
     val prevPhase = ctx.phase.prev // can be a mini-phase
-    val squashedPhase = ctx.squashed(prevPhase)
+    val squashedPhase = ctx.base.squashed(prevPhase)
     val treeString = unit.tpdTree.show(ctx.withProperty(XprintMode, Some(())))
 
     ctx.echo(s"result of $unit after $squashedPhase:")
@@ -268,4 +268,4 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     myUnits = null
     myUnitsCached = null
   }
-}
\ No newline at end of file
+}
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 30dad2f44847..5f69a6f37943 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -126,7 +126,7 @@ object desugar {
     val ValDef(name, tpt, rhs) = vdef
     val mods = vdef.mods
     val setterNeeded =
-      (mods is Mutable) && ctx.owner.isClass && (!(mods is PrivateLocal) || (ctx.owner is Trait))
+      mods.is(Mutable) && ctx.owner.isClass && (!mods.isBoth(Private, and = Local) || ctx.owner.is(Trait))
     if (setterNeeded) {
       // TODO: copy of vdef as getter needed?
       // val getter = ValDef(mods, name, tpt, rhs) withPos vdef.pos?
@@ -149,7 +149,7 @@ object desugar {
 
   def makeImplicitParameters(tpts: List[Tree], forPrimaryConstructor: Boolean = false)(implicit ctx: Context) =
     for (tpt <- tpts) yield {
-       val paramFlags: FlagSet = if (forPrimaryConstructor) PrivateLocalParamAccessor else Param
+       val paramFlags: FlagSet = if (forPrimaryConstructor) Private | Local | ParamAccessor else Param
        val epname = EvidenceParamName.fresh()
        ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | Implicit)
     }
@@ -260,9 +260,9 @@ object desugar {
   @sharable private val synthetic = Modifiers(Synthetic)
 
   private def toDefParam(tparam: TypeDef): TypeDef =
-    tparam.withMods(tparam.rawMods & EmptyFlags | Param)
+    tparam.withMods(tparam.mods & EmptyFlags | Param)
   private def toDefParam(vparam: ValDef): ValDef =
-    vparam.withMods(vparam.rawMods & (Implicit | Erased) | Param)
+    vparam.withMods(vparam.mods & (Implicit | Erased) | Param)
 
   /** The expansion of a class definition. See inline comments for what is involved */
   def classDef(cdef: TypeDef)(implicit ctx: Context): Tree = {
@@ -314,7 +314,7 @@ object desugar {
     lazy val derivedEnumParams = enumClass.typeParams.map(derivedTypeParam)
     val impliedTparams =
       if (isEnumCase && originalTparams.isEmpty)
-        derivedEnumParams.map(tdef => tdef.withFlags(tdef.mods.flags | PrivateLocal))
+        derivedEnumParams.map(tdef => tdef.withFlags(tdef.mods.flags | Private | Local))
       else
         originalTparams
     val constrTparams = impliedTparams.map(toDefParam)
@@ -729,7 +729,7 @@ object desugar {
         case _ =>
           val tmpName = UniqueName.fresh()
           val patMods =
-            mods & Lazy | Synthetic | (if (ctx.owner.isClass) PrivateLocal else EmptyFlags)
+            mods & Lazy | Synthetic | (if (ctx.owner.isClass) Private | Local else EmptyFlags)
           val firstDef =
             ValDef(tmpName, TypeTree(), matchExpr)
               .withPos(pat.pos.union(rhs.pos)).withMods(patMods)
diff --git a/compiler/src/dotty/tools/dotc/ast/Positioned.scala b/compiler/src/dotty/tools/dotc/ast/Positioned.scala
index f8e53f29fb99..66f797c5e334 100644
--- a/compiler/src/dotty/tools/dotc/ast/Positioned.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Positioned.scala
@@ -16,10 +16,12 @@ abstract class Positioned extends DotClass with Product {
 
   setPos(initialPos)
 
-  /** The item's position.
-   */
+  /** The item's position. */
   def pos: Position = curPos
 
+  /** The item's coord. */
+  def coord: Coord = curPos.toCoord
+
  /** Destructively update `curPos` to given position. Also, set any missing
    *  positions in children.
    */
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 29096e44bc38..08dd9543eb62 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -78,7 +78,7 @@ object Trees {
     /** The type  constructor at the root of the tree */
     type ThisTree[T >: Untyped] <: Tree[T]
 
-    private[this] var myTpe: T = _
+    protected var myTpe: T @uncheckedVariance = _
 
     /** Destructively set the type of the tree. This should be called only when it is known that
      *  it is safe under sharing to do so. One use-case is in the withType method below
@@ -91,7 +91,7 @@ object Trees {
     /** The type of the tree. In case of an untyped tree,
      *   an UnAssignedTypeException is thrown. (Overridden by empty trees)
      */
-    def tpe: T @uncheckedVariance = {
+    final def tpe: T @uncheckedVariance = {
       if (myTpe == null)
         throw new UnAssignedTypeException(this)
       myTpe
@@ -310,7 +310,7 @@ object Trees {
 
     private[this] var myMods: untpd.Modifiers = null
 
-    private[dotc] def rawMods: untpd.Modifiers =
+    def mods: untpd.Modifiers =
       if (myMods == null) untpd.EmptyModifiers else myMods
 
     def rawComment: Option[Comment] = getAttachment(DocComment)
@@ -338,7 +338,7 @@ object Trees {
      */
     def namePos =
       if (pos.exists)
-        if (rawMods.is(Synthetic)) Position(pos.point, pos.point)
+        if (mods.is(Synthetic)) Position(pos.point, pos.point)
         else Position(pos.point, pos.point + name.stripModuleClassSuffix.lastPart.length, pos.point)
       else pos
   }
@@ -727,7 +727,6 @@ object Trees {
   }
 
   trait WithoutTypeOrPos[-T >: Untyped] extends Tree[T] {
-    override def tpe: T @uncheckedVariance = NoType.asInstanceOf[T]
     override def withTypeUnchecked(tpe: Type) = this.asInstanceOf[ThisTree[Type]]
     override def pos = NoPosition
     override def setPos(pos: Position) = {}
@@ -740,6 +739,8 @@ object Trees {
    */
   case class Thicket[-T >: Untyped](trees: List[Tree[T]])
     extends Tree[T] with WithoutTypeOrPos[T] {
+    myTpe = NoType.asInstanceOf[T]
+
     type ThisTree[-T >: Untyped] = Thicket[T]
     override def isEmpty: Boolean = trees.isEmpty
     override def toList: List[Tree[T]] = flatten(trees)
@@ -758,8 +759,9 @@ object Trees {
 
   class EmptyValDef[T >: Untyped] extends ValDef[T](
     nme.WILDCARD, genericEmptyTree[T], genericEmptyTree[T]) with WithoutTypeOrPos[T] {
+    myTpe = NoType.asInstanceOf[T]
     override def isEmpty: Boolean = true
-    setMods(untpd.Modifiers(PrivateLocal))
+    setMods(untpd.Modifiers(Private | Local))
   }
 
   @sharable val theEmptyTree: Thicket[Type] = Thicket(Nil)
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index a3be000dbbc2..54a8bf84f35f 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -175,7 +175,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     ta.assignType(untpd.ValDef(sym.name, TypeTree(sym.info), rhs), sym)
 
   def SyntheticValDef(name: TermName, rhs: Tree)(implicit ctx: Context): ValDef =
-    ValDef(ctx.newSymbol(ctx.owner, name, Synthetic, rhs.tpe.widen, coord = rhs.pos), rhs)
+    ValDef(ctx.newSymbol(ctx.owner, name, Synthetic, rhs.tpe.widen, coord = rhs.coord), rhs)
 
   def DefDef(sym: TermSymbol, tparams: List[TypeSymbol], vparamss: List[List[TermSymbol]],
              resultType: Type, rhs: Tree)(implicit ctx: Context): DefDef =
@@ -270,7 +270,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       if (parents.head.classSymbol.is(Trait)) parents.head.parents.head :: parents
       else parents
     val cls = ctx.newNormalizedClassSymbol(owner, tpnme.ANON_CLASS, Synthetic, parents1,
-        coord = fns.map(_.pos).reduceLeft(_ union _))
+        coord = fns.map(_.pos).reduceLeft(_ union _).toCoord)
     val constr = ctx.newConstructor(cls, Synthetic, Nil, Nil).entered
     def forwarder(fn: TermSymbol, name: TermName) = {
       val fwdMeth = fn.copy(cls, name, Synthetic | Method).entered.asTerm
@@ -284,7 +284,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   // { <label> def while$(): Unit = if (cond) { body; while$() } ; while$() }
   def WhileDo(owner: Symbol, cond: Tree, body: List[Tree])(implicit ctx: Context): Tree = {
     val sym = ctx.newSymbol(owner, nme.WHILE_PREFIX, Flags.Label | Flags.Synthetic,
-      MethodType(Nil, defn.UnitType), coord = cond.pos)
+      MethodType(Nil, defn.UnitType), coord = cond.coord)
 
     val call = Apply(ref(sym), Nil)
     val rhs = If(cond, Block(body, call), unitLiteral)
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 252b301c2954..01b5b6d1af4f 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -153,7 +153,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     mods: List[Mod] = Nil) extends Positioned with Cloneable {
 
     def is(fs: FlagSet): Boolean = flags is fs
-    def is(fc: FlagConjunction): Boolean = flags is fc
+    def isBoth(fc: FlagSet, and: FlagSet): Boolean = flags.isBoth(fc, and)
     def is(fc: FlagSet, butNot: FlagSet): Boolean = flags.is(fc, butNot = butNot)
 
     def | (fs: FlagSet): Modifiers = withFlags(flags | fs)
@@ -349,7 +349,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     makeConstructor(Nil, Nil)
 
   def makeSelfDef(name: TermName, tpt: Tree)(implicit ctx: Context) =
-    ValDef(name, tpt, EmptyTree).withFlags(PrivateLocal)
+    ValDef(name, tpt, EmptyTree).withFlags(Private | Local)
 
   def makeTupleOrParens(ts: List[Tree])(implicit ctx: Context) = ts match {
     case t :: Nil => Parens(t)
@@ -365,7 +365,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     ValDef(pname, tpe, EmptyTree).withMods(mods | Param)
 
   def makeSyntheticParameter(n: Int = 1, tpt: Tree = TypeTree())(implicit ctx: Context): ValDef =
-    ValDef(nme.syntheticParamName(n), tpt, EmptyTree).withFlags(SyntheticTermParam)
+    ValDef(nme.syntheticParamName(n), tpt, EmptyTree).withFlags(Synthetic | TermParam)
 
   def lambdaAbstract(tparams: List[TypeDef], tpt: Tree)(implicit ctx: Context) =
     if (tparams.isEmpty) tpt else LambdaTypeTree(tparams, tpt)
@@ -381,14 +381,6 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   /** A repeated argument such as `arg: _*` */
   def repeated(arg: Tree)(implicit ctx: Context) = Typed(arg, Ident(tpnme.WILDCARD_STAR))
 
-// ----- Accessing modifiers ----------------------------------------------------
-
-  abstract class ModsDecorator { def mods: Modifiers }
-
-  implicit class modsDeco(val mdef: MemberDef)(implicit ctx: Context) {
-    def mods = mdef.rawMods
-  }
-
 // --------- Copier/Transformer/Accumulator classes for untyped trees -----
 
   override val cpy: UntypedTreeCopier = new UntypedTreeCopier
@@ -400,7 +392,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
     def postProcess(tree: Tree, copied: MemberDef): copied.ThisTree[Untyped] = {
       tree match {
-        case tree: MemberDef => copied.withMods(tree.rawMods)
+        case tree: MemberDef => copied.withMods(tree.mods)
         case _ => copied
       }
     }.asInstanceOf[copied.ThisTree[Untyped]]
diff --git a/compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala
index a6d22a9719c8..227282ff9ebd 100644
--- a/compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala
+++ b/compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala
@@ -70,7 +70,7 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
   override private[dotty] def list(inPackage: String): ClassPathEntries = {
     val (packages, classesAndSources) = aggregates.map { cp =>
       try {
-        cp.list(inPackage)
+        cp.list(inPackage).toTuple
       } catch {
         case ex: java.io.IOException =>
           val e = new FatalError(ex.getMessage)
diff --git a/compiler/src/dotty/tools/dotc/classpath/ClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/ClassPath.scala
index 89c68ae67112..06a465530db3 100644
--- a/compiler/src/dotty/tools/dotc/classpath/ClassPath.scala
+++ b/compiler/src/dotty/tools/dotc/classpath/ClassPath.scala
@@ -6,12 +6,8 @@ package dotty.tools.dotc.classpath
 import dotty.tools.io.AbstractFile
 import dotty.tools.io.ClassRepresentation
 
-case class ClassPathEntries(packages: Seq[PackageEntry], classesAndSources: Seq[ClassRepresentation])
-
-object ClassPathEntries {
-  import scala.language.implicitConversions
-  // to have working unzip method
-  implicit def entry2Tuple(entry: ClassPathEntries): (Seq[PackageEntry], Seq[ClassRepresentation]) = (entry.packages, entry.classesAndSources)
+case class ClassPathEntries(packages: Seq[PackageEntry], classesAndSources: Seq[ClassRepresentation]) {
+  def toTuple = (packages, classesAndSources)
 }
 
 trait ClassFileEntry extends ClassRepresentation {
diff --git a/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala b/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala
index 03eb441852f0..4402ffb84308 100644
--- a/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala
+++ b/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala
@@ -46,7 +46,7 @@ class JavaPlatform extends Platform {
 
   /** Is the SAMType `cls` also a SAM under the rules of the JVM? */
   def isSam(cls: ClassSymbol)(implicit ctx: Context): Boolean =
-    cls.is(NoInitsTrait) &&
+    cls.isBoth(NoInits, and = Trait) &&
     cls.superClass == defn.ObjectClass &&
     cls.directlyInheritedTraits.forall(_.is(NoInits)) &&
     !ExplicitOuter.needsOuterIfReferenced(cls) &&
diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
index 89d0bef4ba14..abc1aed71d3d 100644
--- a/compiler/src/dotty/tools/dotc/core/Contexts.scala
+++ b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -424,6 +424,31 @@ object Contexts {
       "Context(\n" +
       (outersIterator map ( ctx => s"  owner = ${ctx.owner}, scope = ${ctx.scope}, import = ${iinfo(ctx)}") mkString "\n")
     }
+
+    def typerPhase               = base.typerPhase
+    def picklerPhase             = base.picklerPhase
+    def refchecksPhase           = base.refchecksPhase
+    def patmatPhase              = base.patmatPhase
+    def elimRepeatedPhase        = base.elimRepeatedPhase
+    def extensionMethodsPhase    = base.extensionMethodsPhase
+    def explicitOuterPhase       = base.explicitOuterPhase
+    def gettersPhase             = base.gettersPhase
+    def erasurePhase             = base.erasurePhase
+    def elimErasedValueTypePhase = base.elimErasedValueTypePhase
+    def lambdaLiftPhase          = base.lambdaLiftPhase
+    def flattenPhase             = base.flattenPhase
+    def genBCodePhase            = base.genBCodePhase
+    def phases                   = base.phases
+
+    def settings                 = base.settings
+    def definitions              = base.definitions
+    def platform                 = base.platform
+    def pendingUnderlying        = base.pendingUnderlying
+    def uniqueNamedTypes         = base.uniqueNamedTypes
+    def uniques                  = base.uniques
+    def nextId                   = base.nextId
+
+    def initialize()(implicit ctx: Context) = base.initialize()(ctx)
   }
 
   /** A condensed context provides only a small memory footprint over
@@ -516,7 +541,7 @@ object Contexts {
   /** A class defining the initial context with given context base
    *  and set of possible settings.
    */
-  private class InitialContext(val base: ContextBase, settings: SettingGroup) extends FreshContext {
+  private class InitialContext(val base: ContextBase, settingsGroup: SettingGroup) extends FreshContext {
     outer = NoContext
     period = InitialPeriod
     mode = Mode.None
@@ -525,7 +550,7 @@ object Contexts {
     tree = untpd.EmptyTree
     typeAssigner = TypeAssigner
     moreProperties = Map.empty
-    store = initialStore.updated(settingsStateLoc, settings.defaultState)
+    store = initialStore.updated(settingsStateLoc, settingsGroup.defaultState)
     typeComparer = new TypeComparer(this)
     searchHistory = new SearchHistory(0, Map())
     gadt = EmptyGADTMap
@@ -683,17 +708,6 @@ object Contexts {
       else assert(thread == Thread.currentThread(), "illegal multithreaded access to ContextBase")
   }
 
-  object Context {
-
-    /** Implicit conversion that injects all printer operations into a context */
-    implicit def toPrinter(ctx: Context): Printer = ctx.printer
-
-    /** implicit conversion that injects all ContextBase members into a context */
-    implicit def toBase(ctx: Context): ContextBase = ctx.base
-
-    // @sharable val theBase = new ContextBase // !!! DEBUG, so that we can use a minimal context for reporting even in code that normally cannot access a context
-  }
-
   class GADTMap(initBounds: SimpleIdentityMap[Symbol, TypeBounds]) extends util.DotClass {
     private[this] var myBounds = initBounds
     def setBounds(sym: Symbol, b: TypeBounds): Unit =
diff --git a/compiler/src/dotty/tools/dotc/core/Decorators.scala b/compiler/src/dotty/tools/dotc/core/Decorators.scala
index 9639e520d010..7bc39b424ca5 100644
--- a/compiler/src/dotty/tools/dotc/core/Decorators.scala
+++ b/compiler/src/dotty/tools/dotc/core/Decorators.scala
@@ -13,15 +13,10 @@ import printing.Formatting._
 
 /** This object provides useful implicit decorators for types defined elsewhere */
 object Decorators {
-
-  /** Turns Strings into PreNames, adding toType/TermName methods */
-  implicit class PreNamedString(val s: String) extends AnyVal with PreName {
+  implicit class StringDecorator(val s: String) extends AnyVal {
     def toTypeName: TypeName = typeName(s)
     def toTermName: TermName = termName(s)
-    def toText(printer: Printer): Text = Str(s)
-  }
 
-  implicit class StringDecorator(val s: String) extends AnyVal {
     def splitWhere(f: Char => Boolean, doDropIndex: Boolean): Option[(String, String)] = {
       def splitAt(idx: Int, doDropIndex: Boolean): Option[(String, String)] =
         if (idx == -1) None
@@ -165,7 +160,7 @@ object Decorators {
     }
   }
 
-  implicit def sourcePos(pos: Position)(implicit ctx: Context): SourcePosition = {
+  def sourcePos(pos: Position)(implicit ctx: Context): SourcePosition = {
     def recur(inlinedCalls: List[Tree], pos: Position): SourcePosition = inlinedCalls match {
       case inlinedCall :: rest =>
         sourceFile(inlinedCall).atPos(pos).withOuter(recur(rest, inlinedCall.pos))
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 872f7bd6302e..e543a2e1fed8 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -189,20 +189,20 @@ class Definitions {
   }
 
   lazy val RootClass: ClassSymbol = ctx.newPackageSymbol(
-    NoSymbol, nme.ROOT, (root, rootcls) => ctx.rootLoader(root)).moduleClass.asClass
+    NoSymbol, nme.ROOT, (root, rootcls) => ctx.base.rootLoader(root)).moduleClass.asClass
   lazy val RootPackage: TermSymbol = ctx.newSymbol(
     NoSymbol, nme.ROOTPKG, PackageCreationFlags, TypeRef(NoPrefix, RootClass))
 
   lazy val EmptyPackageVal = ctx.newPackageSymbol(
-    RootClass, nme.EMPTY_PACKAGE, (emptypkg, emptycls) => ctx.rootLoader(emptypkg)).entered
+    RootClass, nme.EMPTY_PACKAGE, (emptypkg, emptycls) => ctx.base.rootLoader(emptypkg)).entered
   lazy val EmptyPackageClass = EmptyPackageVal.moduleClass.asClass
 
   /** A package in which we can place all methods that are interpreted specially by the compiler */
   lazy val OpsPackageVal = ctx.newCompletePackageSymbol(RootClass, nme.OPS_PACKAGE).entered
   lazy val OpsPackageClass = OpsPackageVal.moduleClass.asClass
 
-  lazy val ScalaPackageVal = ctx.requiredPackage("scala")
-  lazy val ScalaMathPackageVal = ctx.requiredPackage("scala.math")
+  lazy val ScalaPackageVal = ctx.requiredPackage(nme.scala_)
+  lazy val ScalaMathPackageVal = ctx.requiredPackage("scala.math".toTermName)
   lazy val ScalaPackageClass = {
     val cls = ScalaPackageVal.moduleClass.asClass
     cls.info.decls.openForMutations.useSynthesizer(
@@ -212,8 +212,8 @@ class Definitions {
     cls
   }
   lazy val ScalaPackageObjectRef = ctx.requiredModuleRef("scala.package")
-  lazy val JavaPackageVal = ctx.requiredPackage("java")
-  lazy val JavaLangPackageVal = ctx.requiredPackage("java.lang")
+  lazy val JavaPackageVal = ctx.requiredPackage(nme.java)
+  lazy val JavaLangPackageVal = ctx.requiredPackage(jnme.JavaLang)
   // fundamental modules
   lazy val SysPackage = ctx.requiredModule("scala.sys.package")
     lazy val Sys_errorR = SysPackage.moduleClass.requiredMethodRef(nme.error)
@@ -325,24 +325,24 @@ class Definitions {
       useCompleter = true)
 
   lazy val NothingClass: ClassSymbol = enterCompleteClassSymbol(
-    ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef))
+    ScalaPackageClass, tpnme.Nothing, Abstract | Final, List(AnyClass.typeRef))
   def NothingType = NothingClass.typeRef
   lazy val RuntimeNothingModuleRef = ctx.requiredModuleRef("scala.runtime.Nothing")
   lazy val NullClass: ClassSymbol = enterCompleteClassSymbol(
-    ScalaPackageClass, tpnme.Null, AbstractFinal, List(ObjectClass.typeRef))
+    ScalaPackageClass, tpnme.Null, Abstract | Final, List(ObjectClass.typeRef))
   def NullType = NullClass.typeRef
   lazy val RuntimeNullModuleRef = ctx.requiredModuleRef("scala.runtime.Null")
 
   lazy val ScalaPredefModuleRef = ctx.requiredModuleRef("scala.Predef")
   def ScalaPredefModule(implicit ctx: Context) = ScalaPredefModuleRef.symbol
 
-    lazy val Predef_ConformsR = ScalaPredefModule.requiredClass("<:<").typeRef
+    lazy val Predef_ConformsR = ScalaPredefModule.requiredClass("<:<".toTypeName).typeRef
     def Predef_Conforms(implicit ctx: Context) = Predef_ConformsR.symbol
-    lazy val Predef_conformsR = ScalaPredefModule.requiredMethodRef("$conforms")
+    lazy val Predef_conformsR = ScalaPredefModule.requiredMethodRef(nme.conforms_)
     def Predef_conforms(implicit ctx: Context) = Predef_conformsR.symbol
-    lazy val Predef_classOfR = ScalaPredefModule.requiredMethodRef("classOf")
+    lazy val Predef_classOfR = ScalaPredefModule.requiredMethodRef(nme.classOf)
     def Predef_classOf(implicit ctx: Context) = Predef_classOfR.symbol
-    lazy val Predef_undefinedR = ScalaPredefModule.requiredMethodRef("???")
+    lazy val Predef_undefinedR = ScalaPredefModule.requiredMethodRef(nme.???)
     def Predef_undefined(implicit ctx: Context) = Predef_undefinedR.symbol
     // The set of all wrap{X, Ref}Array methods, where X is a value type
     val Predef_wrapArray = new PerRun[collection.Set[Symbol]]({ implicit ctx =>
@@ -354,7 +354,7 @@ class Definitions {
   def ScalaRuntimeModule(implicit ctx: Context) = ScalaRuntimeModuleRef.symbol
   def ScalaRuntimeClass(implicit ctx: Context) = ScalaRuntimeModule.moduleClass.asClass
 
-    def runtimeMethodRef(name: PreName) = ScalaRuntimeModule.requiredMethodRef(name)
+    def runtimeMethodRef(name: TermName) = ScalaRuntimeModule.requiredMethodRef(name)
     def ScalaRuntime_dropR(implicit ctx: Context) = runtimeMethodRef(nme.drop)
     def ScalaRuntime_drop(implicit ctx: Context) = ScalaRuntime_dropR.symbol
 
@@ -365,8 +365,8 @@ class Definitions {
   def ScalaStaticsModule(implicit ctx: Context) = ScalaStaticsModuleRef.symbol
   def ScalaStaticsClass(implicit ctx: Context) = ScalaStaticsModule.moduleClass.asClass
 
-    def staticsMethodRef(name: PreName) = ScalaStaticsModule.requiredMethodRef(name)
-    def staticsMethod(name: PreName) = ScalaStaticsModule.requiredMethod(name)
+    def staticsMethodRef(name: TermName) = ScalaStaticsModule.requiredMethodRef(name)
+    def staticsMethod(name: TermName): TermSymbol = ScalaStaticsModule.requiredMethod(name)
 
   // Dotty deviation: we cannot use a lazy val here because lazy vals in dotty
   // will return "null" when called recursively, see #1856.
@@ -381,13 +381,13 @@ class Definitions {
 
   def DottyPredefModule(implicit ctx: Context) = DottyPredefModuleRef.symbol
 
-    lazy val Predef_ImplicitConverterR = DottyPredefModule.requiredClass("ImplicitConverter").typeRef
+    lazy val Predef_ImplicitConverterR = DottyPredefModule.requiredClass("ImplicitConverter".toTypeName).typeRef
     def Predef_ImplicitConverter(implicit ctx: Context) = Predef_ImplicitConverterR.symbol
 
   lazy val DottyArraysModuleRef = ctx.requiredModuleRef("dotty.runtime.Arrays")
   def DottyArraysModule(implicit ctx: Context) = DottyArraysModuleRef.symbol
-    def newGenericArrayMethod(implicit ctx: Context) = DottyArraysModule.requiredMethod("newGenericArray")
-    def newArrayMethod(implicit ctx: Context) = DottyArraysModule.requiredMethod("newArray")
+    def newGenericArrayMethod(implicit ctx: Context) = DottyArraysModule.requiredMethod("newGenericArray".toTermName)
+    def newArrayMethod(implicit ctx: Context) = DottyArraysModule.requiredMethod("newArray".toTermName)
 
   lazy val NilModuleRef = ctx.requiredModuleRef("scala.collection.immutable.Nil")
   def NilModule(implicit ctx: Context) = NilModuleRef.symbol
@@ -494,7 +494,7 @@ class Definitions {
   lazy val BoxedUnitType: TypeRef = ctx.requiredClassRef("scala.runtime.BoxedUnit")
   def BoxedUnitClass(implicit ctx: Context) = BoxedUnitType.symbol.asClass
 
-    def BoxedUnit_UNIT(implicit ctx: Context) = BoxedUnitClass.linkedClass.requiredValue("UNIT")
+    def BoxedUnit_UNIT(implicit ctx: Context) = BoxedUnitClass.linkedClass.requiredValue("UNIT".toTermName)
 
   lazy val BoxedBooleanType: TypeRef = ctx.requiredClassRef("java.lang.Boolean")
   def BoxedBooleanClass(implicit ctx: Context) = BoxedBooleanType.symbol.asClass
@@ -635,8 +635,8 @@ class Definitions {
     lazy val QuotedType_applyR = QuotedTypeModule.requiredMethodRef(nme.apply)
     def QuotedType_apply(implicit ctx: Context) = QuotedType_applyR.symbol
 
-  def Unpickler_unpickleExpr = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleExpr")
-  def Unpickler_unpickleType = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleType")
+  def Unpickler_unpickleExpr = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleExpr".toTermName)
+  def Unpickler_unpickleType = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleType".toTermName)
 
   lazy val EqType = ctx.requiredClassRef("scala.Eq")
   def EqClass(implicit ctx: Context) = EqType.symbol.asClass
@@ -1186,5 +1186,4 @@ class Definitions {
       _isInitialized = true
     }
   }
-
 }
diff --git a/compiler/src/dotty/tools/dotc/core/DenotTransformers.scala b/compiler/src/dotty/tools/dotc/core/DenotTransformers.scala
index c62008e6eada..61b75ec48cf9 100644
--- a/compiler/src/dotty/tools/dotc/core/DenotTransformers.scala
+++ b/compiler/src/dotty/tools/dotc/core/DenotTransformers.scala
@@ -22,7 +22,7 @@ object DenotTransformers {
   trait DenotTransformer extends Phase {
 
     /** The last phase during which the transformed denotations are valid */
-    def lastPhaseId(implicit ctx: Context) = ctx.nextDenotTransformerId(id + 1)
+    def lastPhaseId(implicit ctx: Context) = ctx.base.nextDenotTransformerId(id + 1)
 
     /** The validity period of the transformer in the given context */
     def validFor(implicit ctx: Context): Period =
diff --git a/compiler/src/dotty/tools/dotc/core/Denotations.scala b/compiler/src/dotty/tools/dotc/core/Denotations.scala
index c82b1c1e85ca..000a3dda6cf9 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -23,6 +23,7 @@ import config.Config
 import util.common._
 import collection.mutable.ListBuffer
 import Decorators.SymbolIteratorDecorator
+import SymDenotations.LazyType
 
 /** Denotations represent the meaning of symbols and named types.
  *  The following diagram shows how the principal types of denotations
@@ -171,12 +172,19 @@ object Denotations {
    *
    *  @param symbol  The referencing symbol, or NoSymbol is none exists
    */
-  abstract class Denotation(val symbol: Symbol) extends PreDenotation with printing.Showable {
-
+  abstract class Denotation(val symbol: Symbol, protected var myInfo: Type) extends PreDenotation with printing.Showable {
     type AsSeenFromResult <: Denotation
 
-    /** The type info of the denotation, exists only for non-overloaded denotations */
-    def info(implicit ctx: Context): Type
+    /** The type info.
+     *  The info is an instance of TypeType iff this is a type denotation
+     *  Uncompleted denotations set myInfo to a LazyType.
+     */
+    final def info(implicit ctx: Context): Type = {
+      def completeInfo = { // Written this way so that `info` is small enough to be inlined
+        this.asInstanceOf[SymDenotation].completeFrom(myInfo.asInstanceOf[LazyType]); info
+      }
+      if (myInfo.isInstanceOf[LazyType]) completeInfo else myInfo
+    }
 
     /** The type info, or, if this is a SymDenotation where the symbol
      *  is not yet completed, the completer
@@ -287,13 +295,14 @@ object Denotations {
           denot.symbol
       }
 
-    def requiredMethod(name: PreName)(implicit ctx: Context): TermSymbol =
-      info.member(name.toTermName).requiredSymbol(_ is Method).asTerm
-    def requiredMethodRef(name: PreName)(implicit ctx: Context): TermRef =
+    def requiredMethod(name: TermName)(implicit ctx: Context): TermSymbol =
+      info.member(name).requiredSymbol(_ is Method).asTerm
+
+    def requiredMethodRef(name: TermName)(implicit ctx: Context): TermRef =
       requiredMethod(name).termRef
 
-    def requiredMethod(name: PreName, argTypes: List[Type])(implicit ctx: Context): TermSymbol = {
-      info.member(name.toTermName).requiredSymbol { x =>
+    def requiredMethod(name: TermName, argTypes: List[Type])(implicit ctx: Context): TermSymbol = {
+      info.member(name).requiredSymbol { x =>
         (x is Method) && {
           x.info.paramInfoss match {
             case paramInfos :: Nil => paramInfos.corresponds(argTypes)(_ =:= _)
@@ -302,19 +311,18 @@ object Denotations {
         }
       }.asTerm
     }
-    def requiredMethodRef(name: PreName, argTypes: List[Type])(implicit ctx: Context): TermRef =
+
+    def requiredMethodRef(name: TermName, argTypes: List[Type])(implicit ctx: Context): TermRef =
       requiredMethod(name, argTypes).termRef
 
-    def requiredValue(name: PreName)(implicit ctx: Context): TermSymbol =
-      info.member(name.toTermName).requiredSymbol(_.info.isParameterless).asTerm
-    def requiredValueRef(name: PreName)(implicit ctx: Context): TermRef =
-      requiredValue(name).termRef
+    def requiredValue(name: TermName)(implicit ctx: Context): TermSymbol =
+      info.member(name).requiredSymbol(_.info.isParameterless).asTerm
 
-    def requiredClass(name: PreName)(implicit ctx: Context): ClassSymbol =
+    def requiredClass(name: TypeName)(implicit ctx: Context): ClassSymbol =
       info.member(name.toTypeName).requiredSymbol(_.isClass).asClass
 
-    def requiredType(name: PreName)(implicit ctx: Context): TypeSymbol =
-      info.member(name.toTypeName).requiredSymbol(_.isType).asType
+    def requiredType(name: TypeName)(implicit ctx: Context): TypeSymbol =
+      info.member(name).requiredSymbol(_.isType).asType
 
     /** The alternative of this denotation that has a type matching `targetType` when seen
      *  as a member of type `site`, `NoDenotation` if none exists.
@@ -646,7 +654,7 @@ object Denotations {
   }
 
   /** A non-overloaded denotation */
-  abstract class SingleDenotation(symbol: Symbol) extends Denotation(symbol) {
+  abstract class SingleDenotation(symbol: Symbol, initInfo: Type) extends Denotation(symbol, initInfo) {
     protected def newLikeThis(symbol: Symbol, info: Type): SingleDenotation
 
     final def name(implicit ctx: Context): Name = symbol.name
@@ -861,12 +869,12 @@ object Denotations {
           } else {
             //println(s"might need new denot for $cur, valid for ${cur.validFor} at $currentPeriod")
             // not found, cur points to highest existing variant
-            val nextTransformerId = ctx.nextDenotTransformerId(cur.validFor.lastPhaseId)
+            val nextTransformerId = ctx.base.nextDenotTransformerId(cur.validFor.lastPhaseId)
             if (currentPeriod.lastPhaseId <= nextTransformerId)
               cur.validFor = Period(currentPeriod.runId, cur.validFor.firstPhaseId, nextTransformerId)
             else {
               var startPid = nextTransformerId + 1
-              val transformer = ctx.denotTransformers(nextTransformerId)
+              val transformer = ctx.base.denotTransformers(nextTransformerId)
               //println(s"transforming $this with $transformer")
               try {
                 next = transformer.transform(cur)(ctx.withPhase(transformer))
@@ -1018,7 +1026,7 @@ object Denotations {
     /** Show declaration string; useful for showing declarations
      *  as seen from subclasses.
      */
-    def showDcl(implicit ctx: Context): String = ctx.dclText(this).show
+    def showDcl(implicit ctx: Context): String = ctx.printer.dclText(this).show
 
     override def toString =
       if (symbol == NoSymbol) symbol.toString
@@ -1076,16 +1084,15 @@ object Denotations {
     }
   }
 
-  abstract class NonSymSingleDenotation(symbol: Symbol) extends SingleDenotation(symbol) {
-    def infoOrCompleter: Type
-    def info(implicit ctx: Context) = infoOrCompleter
+  abstract class NonSymSingleDenotation(symbol: Symbol, initInfo: Type) extends SingleDenotation(symbol, initInfo) {
+    def infoOrCompleter: Type = initInfo
     def isType = infoOrCompleter.isInstanceOf[TypeType]
   }
 
   class UniqueRefDenotation(
     symbol: Symbol,
-    val infoOrCompleter: Type,
-    initValidFor: Period) extends NonSymSingleDenotation(symbol) {
+    initInfo: Type,
+    initValidFor: Period) extends NonSymSingleDenotation(symbol, initInfo) {
     validFor = initValidFor
     override def hasUniqueSym: Boolean = true
     protected def newLikeThis(s: Symbol, i: Type): SingleDenotation = new UniqueRefDenotation(s, i, validFor)
@@ -1093,17 +1100,16 @@ object Denotations {
 
   class JointRefDenotation(
     symbol: Symbol,
-    val infoOrCompleter: Type,
-    initValidFor: Period) extends NonSymSingleDenotation(symbol) {
+    initInfo: Type,
+    initValidFor: Period) extends NonSymSingleDenotation(symbol, initInfo) {
     validFor = initValidFor
     override def hasUniqueSym = false
     protected def newLikeThis(s: Symbol, i: Type): SingleDenotation = new JointRefDenotation(s, i, validFor)
   }
 
-  class ErrorDenotation(implicit ctx: Context) extends NonSymSingleDenotation(NoSymbol) {
+  class ErrorDenotation(implicit ctx: Context) extends NonSymSingleDenotation(NoSymbol, NoType) {
     override def exists = false
     override def hasUniqueSym = false
-    def infoOrCompleter = NoType
     validFor = Period.allInRun(ctx.runId)
     protected def newLikeThis(s: Symbol, i: Type): SingleDenotation = this
   }
@@ -1185,9 +1191,9 @@ object Denotations {
 
   /** An overloaded denotation consisting of the alternatives of both given denotations.
    */
-  case class MultiDenotation(denot1: Denotation, denot2: Denotation) extends Denotation(NoSymbol) with MultiPreDenotation {
+  case class MultiDenotation(denot1: Denotation, denot2: Denotation) extends Denotation(NoSymbol, NoType) with MultiPreDenotation {
     final def infoOrCompleter = multiHasNot("info")
-    final def info(implicit ctx: Context) = infoOrCompleter
+    // final def info(implicit ctx: Context) = infoOrCompleter
     final def validFor = denot1.validFor & denot2.validFor
     final def isType = false
     final def hasUniqueSym = false
diff --git a/compiler/src/dotty/tools/dotc/core/Flags.scala b/compiler/src/dotty/tools/dotc/core/Flags.scala
index 9f88fdbc0cf3..fd37a2716ba6 100644
--- a/compiler/src/dotty/tools/dotc/core/Flags.scala
+++ b/compiler/src/dotty/tools/dotc/core/Flags.scala
@@ -4,7 +4,6 @@ package core
 import language.implicitConversions
 
 object Flags {
-
   /** A FlagSet represents a set of flags. Flags are encoded as follows:
    *  The first two bits indicate whether a flagset applies to terms,
    *  to types, or to both.  Bits 2..63 are available for properties
@@ -15,8 +14,7 @@ object Flags {
    */
   case class FlagSet(val bits: Long) extends AnyVal {
 
-    /** The union of this flag set and the given flag set
-     */
+    /** The union of this flag set and the given flag set */
     def | (that: FlagSet): FlagSet =
       if (bits == 0) that
       else if (that.bits == 0) this
@@ -39,6 +37,10 @@ object Flags {
 
     /** Does this flag set have a non-empty intersection with the given flag set?
      *  This means that both the kind flags and the carrier bits have non-empty intersection.
+     *
+     *  Note that `.is(flagA | flagB)` returns true if this flag set contains
+     *  EITHER `flagA` OR `flagB`. To test for both conjunction of both flags,
+     *  use `.is(flagA, and = flagB)`.
      */
     def is(flags: FlagSet): Boolean = {
       val fs = bits & flags.bits
@@ -48,22 +50,18 @@ object Flags {
    /** Does this flag set have a non-empty intersection with the given flag set,
     *  and at the same time contain none of the flags in the `butNot` set?
     */
-    def is(flags: FlagSet, butNot: FlagSet): Boolean = is(flags) && !is(butNot)
+    def is(flags: FlagSet, butNot: FlagSet): Boolean =
+      is(flags) && !is(butNot)
 
-    /** Does this flag set have all of the flags in given flag conjunction?
-     *  Pre: The intersection of the typeflags of both sets must be non-empty.
-     */
-    def is(flags: FlagConjunction): Boolean = {
-      val fs = bits & flags.bits
-      (fs & KINDFLAGS) != 0 &&
-      (fs >>> TYPESHIFT) == (flags.bits >>> TYPESHIFT)
-    }
+    /** Does this flag set have both of the given flags? */
+    def isBoth(flags: FlagSet, and: FlagSet): Boolean =
+      is(flags) && is(and)
 
     /** Does this flag set have all of the flags in given flag conjunction?
      *  and at the same time contain none of the flags in the `butNot` set?
-     *  Pre: The intersection of the typeflags of both sets must be non-empty.
      */
-    def is(flags: FlagConjunction, butNot: FlagSet): Boolean = is(flags) && !is(butNot)
+    def isBoth(flags: FlagSet, and: FlagSet, butNot: FlagSet): Boolean =
+      is(flags) && is(and) && !is(butNot)
 
     def isEmpty = (bits & ~KINDFLAGS) == 0
 
@@ -119,14 +117,6 @@ object Flags {
     override def toString = flagStrings.mkString(" ")
   }
 
-  /** A class representing flag sets that should be tested
-   *  conjunctively. I.e. for a flag conjunction `fc`,
-   *  `x is fc` tests whether `x` contains all flags in `fc`.
-   */
-  case class FlagConjunction(bits: Long) {
-    override def toString = FlagSet(bits).toString
-  }
-
   private final val TYPESHIFT = 2
   private final val TERMindex = 0
   private final val TYPEindex = 1
@@ -179,19 +169,6 @@ object Flags {
     flag
   }
 
-  /** The conjunction of all flags in given flag set */
-  def allOf(flags1: FlagSet, flags2: FlagSet): FlagConjunction = {
-    assert(flags1.numFlags == 1 && flags2.numFlags == 1, "Flags.allOf doesn't support flag " + (if (flags1.numFlags != 1) flags1 else flags2))
-    FlagConjunction((flags1 | flags2).bits)
-  }
-
-  /** The conjunction of all flags in given flag set */
-  def allOf(flags1: FlagSet, flags2: FlagSet, flags3: FlagSet, flagss: FlagSet*): FlagConjunction = {
-    val flags0 = allOf(flags1, flags2) | flags3
-    assert(flags3.numFlags == 1 && flagss.forall(_.numFlags == 1), "Flags.allOf doesn't support flag " + (if (flags3.numFlags != 1) flags3 else flagss.find(_.numFlags != 1)))
-    FlagConjunction((flags0 | union(flagss: _*)).bits)
-  }
-
   def commonFlags(flagss: FlagSet*) = union(flagss.map(_.toCommonFlags): _*)
 
   /** The empty flag set */
@@ -550,18 +527,6 @@ object Flags {
   /** Labeled `private`, `final`, or `inline` */
   final val PrivateOrFinalOrInline = Private | Final | Inline
 
-  /** A private method */
-  final val PrivateMethod = allOf(Private, Method)
-
-  /** A private accessor */
-  final val PrivateAccessor = allOf(Private, Accessor)
-
-  /** An inline method */
-  final val InlineMethod = allOf(Inline, Method)
-
-  /** An inline parameter */
-  final val InlineParam = allOf(Inline, Param)
-
   /** A term parameter or parameter accessor */
   final val TermParamOrAccessor = Param | ParamAccessor
 
@@ -583,76 +548,9 @@ object Flags {
   /** value that's final or inline */
   final val FinalOrInline = Final | Inline
 
-  /** A covariant type parameter instance */
-  final val LocalCovariant = allOf(Local, Covariant)
-
-  /** A contravariant type parameter instance */
-  final val LocalContravariant = allOf(Local, Contravariant)
-
   /** Has defined or inherited default parameters */
   final val HasDefaultParams = DefaultParameterized | InheritedDefaultParams
 
   /** Is valid forever */
   final val ValidForever = Package | Permanent | Scala2ExistentialCommon
-
-  /** A type parameter of a class or trait */
-  final val ClassTypeParam = allOf(TypeParam, Private)
-
-  /** Is a default parameter in Scala 2*/
-  final val DefaultParameter = allOf(Param, DefaultParameterized)
-
-  /** A Scala 2 Macro */
-  final val Scala2Macro = allOf(Macro, Scala2x)
-
-  /** A trait that does not need to be initialized */
-  final val NoInitsTrait = allOf(Trait, NoInits)
-
-  /** A Java interface, potentially with default methods */
-  final val JavaTrait = allOf(JavaDefined, Trait, NoInits)
-
-    /** A Java interface */ // TODO when unpickling, reconstitute from context
-  final val JavaInterface = allOf(JavaDefined, Trait)
-
-  /** A Java companion object */
-  final val JavaModule = allOf(JavaDefined, Module)
-
-  /** A Java companion object */
-  final val JavaProtected = allOf(JavaDefined, Protected)
-
-  /** Labeled private[this] */
-  final val PrivateLocal = allOf(Private, Local)
-
-  /** A private[this] parameter accessor */
-  final val PrivateLocalParamAccessor = allOf(Private, Local, ParamAccessor)
-
-  /** A parameter forwarder */
-  final val ParamForwarder = allOf(Method, Stable, ParamAccessor)
-
-  /** A private[this] parameter */
-  final val PrivateLocalParam = allOf(Private, Local, Param)
-
-  /** A private parameter accessor */
-  final val PrivateParamAccessor = allOf(Private, ParamAccessor)
-
-  /** A local parameter */
-  final val ParamAndLocal = allOf(Param, Local)
-
-  /** Labeled protected[this] */
-  final val ProtectedLocal = allOf(Protected, Local)
-
-  /** Java symbol which is `protected` and `static` */
-  final val StaticProtected = allOf(JavaDefined, Protected, JavaStatic)
-
-  final val AbstractFinal = allOf(Abstract, Final)
-  final val AbstractSealed = allOf(Abstract, Sealed)
-  final val SyntheticArtifact = allOf(Synthetic, Artifact)
-  final val SyntheticModule = allOf(Synthetic, Module)
-  final val SyntheticTermParam = allOf(Synthetic, TermParam)
-  final val SyntheticTypeParam = allOf(Synthetic, TypeParam)
-  final val SyntheticCase = allOf(Synthetic, Case)
-  final val AbstractAndOverride = allOf(Abstract, Override)
-  final val Scala2Trait = allOf(Scala2x, Trait)
-
-  implicit def conjToFlagSet(conj: FlagConjunction): FlagSet =
-    FlagSet(conj.bits)
 }
diff --git a/compiler/src/dotty/tools/dotc/core/NameOps.scala b/compiler/src/dotty/tools/dotc/core/NameOps.scala
index 584139248959..f06852c265b5 100644
--- a/compiler/src/dotty/tools/dotc/core/NameOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/NameOps.scala
@@ -5,7 +5,7 @@ import java.security.MessageDigest
 import scala.annotation.switch
 import scala.io.Codec
 import Names._, StdNames._, Contexts._, Symbols._, Flags._, NameKinds._
-import Decorators.PreNamedString
+import Decorators.StringDecorator
 import util.{Chars, NameTransformer}
 import Chars.isOperatorPart
 import Definitions._
@@ -58,7 +58,7 @@ object NameOps {
       case _ => false
     }
 
-    def likeSpaced(n: PreName): N =
+    def likeSpaced(n: Name): N =
       (if (name.isTermName) n.toTermName else n.toTypeName).asInstanceOf[N]
 
     def isConstructorName = name == CONSTRUCTOR || name == TRAIT_CONSTRUCTOR
diff --git a/compiler/src/dotty/tools/dotc/core/Names.scala b/compiler/src/dotty/tools/dotc/core/Names.scala
index 7a5cf6f6f249..cbbfb75e8264 100644
--- a/compiler/src/dotty/tools/dotc/core/Names.scala
+++ b/compiler/src/dotty/tools/dotc/core/Names.scala
@@ -19,14 +19,6 @@ import java.util.HashMap
 object Names {
   import NameKinds._
 
-  /** A common class for things that can be turned into names.
-   *  Instances are both names and strings, the latter via a decorator.
-   */
-  trait PreName extends Any with Showable {
-    def toTypeName: TypeName
-    def toTermName: TermName
-  }
-
   implicit def eqName: Eq[Name, Name] = Eq
 
   /** A common superclass of Name and Symbol. After bootstrap, this should be
@@ -39,7 +31,7 @@ object Names {
    *  in a name table. A derived term name adds a tag, and possibly a number
    *  or a further simple name to some other name.
    */
-  abstract class Name extends Designator with PreName {
+  abstract class Name extends Designator with Showable {
 
     /** A type for names of the same kind as this name */
     type ThisName <: Name
diff --git a/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala b/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
index 73ed67a08208..2a971cbb7428 100644
--- a/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
@@ -601,7 +601,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
         " := " ~ tp.toText(printer)
     }
     val indent = 3
-    val header: Text = "Constraint("
+    val header: Text = "Constraint(".toText
     val uninstVarsText = " uninstVars = " ~
       Text(uninstVars map (_.toText(printer)), ", ") ~ ";"
     val constrainedText =
@@ -626,7 +626,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
               Text(ups.map(_.toText(printer)), ", ")
         Text(deps, "\n")
       }
-    Text.lines(List(header, uninstVarsText, constrainedText, boundsText, orderingText, ")"))
+    Text.lines(List(header, uninstVarsText, constrainedText, boundsText, orderingText, ")".toText))
   }
 
   override def toString: String = {
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index 1e64ff94d872..d3ce9abec27b 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -7,7 +7,7 @@ import scala.annotation.switch
 import Names._
 import Symbols._
 import Contexts._
-import Decorators.PreNamedString
+import Decorators.StringDecorator
 import util.NameTransformer
 import scala.collection.breakOut
 
@@ -47,17 +47,17 @@ object StdNames {
   }
 
   abstract class DefinedNames[N <: Name] {
-    protected implicit def fromString(s: String): N
-    protected def fromName(name: Name): N = fromString(name.toString)
+    protected def n(s: String): N
+    protected def fromName(name: Name): N = n(name.toString)
 
     private val kws = mutable.Set[N]()
-    protected def kw(name: N) = { kws += name; name }
+    protected def kw(s: String) = { val name = n(s); kws += name; name }
 
     final val keywords: collection.Set[N] = kws
   }
 
   abstract class ScalaNames[N <: Name] extends DefinedNames[N] {
-    protected def encode(s: String): N = fromName(fromString(s).encode)
+    protected def encode(s: String): N = fromName(n(s).encode)
 
 // Keywords, need to come first -----------------------
 
@@ -115,531 +115,526 @@ object StdNames {
     final val HASHkw: N      = kw("#")
     final val ATkw: N        = kw("@")
 
-    val ANON_CLASS: N                 = str.ANON_CLASS
-    val ANON_FUN: N                   = str.ANON_FUN
-    val BITMAP_PREFIX: N              = "bitmap$"  // @darkdimius: $bitmap? Also, the next 4 names are unused.
-    val BITMAP_NORMAL: N              = BITMAP_PREFIX         // initialization bitmap for public/protected lazy vals
-    val BITMAP_TRANSIENT: N           = BITMAP_PREFIX + "trans$"    // initialization bitmap for transient lazy vals
-    val BITMAP_CHECKINIT: N           = BITMAP_PREFIX + "init$"      // initialization bitmap for checkinit values
-    val BITMAP_CHECKINIT_TRANSIENT: N = BITMAP_PREFIX + "inittrans$" // initialization bitmap for transient checkinit values
-    val DEFAULT_GETTER: N             = str.DEFAULT_GETTER
-    val DEFAULT_GETTER_INIT: N        = "$lessinit$greater"
-    val DO_WHILE_PREFIX: N            = "doWhile$"
-    val DOLLAR_VALUES: N              = "$values"
-    val DOLLAR_NEW: N                 = "$new"
-    val EMPTY: N                      = ""
-    val EMPTY_PACKAGE: N              = "<empty>"
-    val EXCEPTION_RESULT_PREFIX: N    = "exceptionResult"
-    val EXPAND_SEPARATOR: N           = str.EXPAND_SEPARATOR
-    val IMPL_CLASS_SUFFIX: N          = "$class"
-    val IMPORT: N                     = "<import>"
-    val MODULE_SUFFIX: N              = str.MODULE_SUFFIX
-    val OPS_PACKAGE: N                = "<special-ops>"
-    val OVERLOADED: N                 = "<overloaded>"
-    val PACKAGE: N                    = "package"
-    val ROOT: N                       = "<root>"
-    val SPECIALIZED_SUFFIX: N         = "$sp"
-    val SUPER_PREFIX: N               = "super$"
-    val WHILE_PREFIX: N               = "while$"
-    val DEFAULT_EXCEPTION_NAME: N     = "ex$"
-    val INITIALIZER_PREFIX: N         = "initial$"
-    val COMPANION_MODULE_METHOD: N    = "companion$module"
-    val COMPANION_CLASS_METHOD: N     = "companion$class"
-    val BOUNDTYPE_ANNOT: N            = "$boundType$"
-    val QUOTE: N                      = "'"
-    val TYPE_QUOTE: N                = "type_'"
-    val TRAIT_SETTER_SEPARATOR: N     = str.TRAIT_SETTER_SEPARATOR
+    val ANON_CLASS: N                 = n(str.ANON_CLASS)
+    val ANON_FUN: N                   = n(str.ANON_FUN)
+    val BITMAP_PREFIX: N              = n("bitmap$")  // @darkdimius: $bitmap?
+    val DEFAULT_GETTER: N             = n(str.DEFAULT_GETTER)
+    val DEFAULT_GETTER_INIT: N        = n("$lessinit$greater")
+    val DO_WHILE_PREFIX: N            = n("doWhile$")
+    val DOLLAR_VALUES: N              = n("$values")
+    val DOLLAR_NEW: N                 = n("$new")
+    val EMPTY: N                      = n("")
+    val EMPTY_PACKAGE: N              = n("<empty>")
+    val EXCEPTION_RESULT_PREFIX: N    = n("exceptionResult")
+    val EXPAND_SEPARATOR: N           = n(str.EXPAND_SEPARATOR)
+    val IMPL_CLASS_SUFFIX: N          = n("$class")
+    val IMPORT: N                     = n("<import>")
+    val MODULE_SUFFIX: N              = n(str.MODULE_SUFFIX)
+    val OPS_PACKAGE: N                = n("<special-ops>")
+    val OVERLOADED: N                 = n("<overloaded>")
+    val PACKAGE: N                    = n("package")
+    val ROOT: N                       = n("<root>")
+    val SPECIALIZED_SUFFIX: N         = n("$sp")
+    val SUPER_PREFIX: N               = n("super$")
+    val WHILE_PREFIX: N               = n("while$")
+    val DEFAULT_EXCEPTION_NAME: N     = n("ex$")
+    val INITIALIZER_PREFIX: N         = n("initial$")
+    val COMPANION_MODULE_METHOD: N    = n("companion$module")
+    val COMPANION_CLASS_METHOD: N     = n("companion$class")
+    val BOUNDTYPE_ANNOT: N            = n("$boundType$")
+    val QUOTE: N                      = n("'")
+    val TYPE_QUOTE: N                 = n("type_'")
+    val TRAIT_SETTER_SEPARATOR: N     = n(str.TRAIT_SETTER_SEPARATOR)
 
     // value types (and AnyRef) are all used as terms as well
     // as (at least) arguments to the @specialize annotation.
-    final val Boolean: N = "Boolean"
-    final val Byte: N    = "Byte"
-    final val Char: N    = "Char"
-    final val Double: N  = "Double"
-    final val Float: N   = "Float"
-    final val Int: N     = "Int"
-    final val Long: N    = "Long"
-    final val Short: N   = "Short"
-    final val Unit: N    = "Unit"
+    final val Boolean: N = n("Boolean")
+    final val Byte: N    = n("Byte")
+    final val Char: N    = n("Char")
+    final val Double: N  = n("Double")
+    final val Float: N   = n("Float")
+    final val Int: N     = n("Int")
+    final val Long: N    = n("Long")
+    final val Short: N   = n("Short")
+    final val Unit: N    = n("Unit")
 
     final val ScalaValueNames: scala.List[N] =
       scala.List(Byte, Char, Short, Int, Long, Float, Double, Boolean, Unit)
 
     // some types whose companions we utilize
-    final val AnyRef: N     = "AnyRef"
-    final val Array: N      = "Array"
-    final val List: N       = "List"
-    final val Seq: N        = "Seq"
-    final val Symbol: N     = "Symbol"
-    final val ClassTag: N   = "ClassTag"
-    final val classTag: N   = "classTag"
-    final val WeakTypeTag: N = "WeakTypeTag"
-    final val TypeTag : N   = "TypeTag"
-    final val typeTag: N    = "typeTag"
-    final val Expr: N       = "Expr"
-    final val String: N     = "String"
-    final val Annotation: N = "Annotation"
+    final val AnyRef: N      = n("AnyRef")
+    final val Array: N       = n("Array")
+    final val List: N        = n("List")
+    final val Seq: N         = n("Seq")
+    final val Symbol: N      = n("Symbol")
+    final val ClassTag: N    = n("ClassTag")
+    final val classTag: N    = n("classTag")
+    final val WeakTypeTag: N = n("WeakTypeTag")
+    final val TypeTag : N    = n("TypeTag")
+    final val typeTag: N     = n("typeTag")
+    final val Expr: N        = n("Expr")
+    final val String: N      = n("String")
+    final val Annotation: N  = n("Annotation")
 
     // fictions we use as both types and terms
-    final val ERROR: N    = "<error>"
-    final val NO_NAME: N  = "<none>"  // formerly NOSYMBOL
-    final val WILDCARD: N = "_"
+    final val ERROR: N    = n("<error>")
+    final val NO_NAME: N  = n("<none>")  // formerly NOSYMBOL
+    final val WILDCARD: N = n("_")
 
 // ----- Type names -----------------------------------------
 
-    final val BYNAME_PARAM_CLASS: N             = "<byname>"
-    final val EQUALS_PATTERN: N                 = "<equals>"
-    final val LOCAL_CHILD: N                    = "<local child>"
-    final val REPEATED_PARAM_CLASS: N           = "<repeated>"
-    final val WILDCARD_STAR: N                  = "_*"
-    final val REIFY_TREECREATOR_PREFIX: N       = "$treecreator"
-    final val REIFY_TYPECREATOR_PREFIX: N       = "$typecreator"
-
-    final val Any: N                 = "Any"
-    final val AnyVal: N              = "AnyVal"
-    final val ExprApi: N             = "ExprApi"
-    final val Mirror: N              = "Mirror"
-    final val Nothing: N             = "Nothing"
-    final val Null: N                = "Null"
-    final val Object: N              = "Object"
-    final val PartialFunction: N     = "PartialFunction"
-    final val PrefixType: N          = "PrefixType"
-    final val Serializable: N        = "Serializable"
-    final val Singleton: N           = "Singleton"
-    final val Throwable: N           = "Throwable"
-
-    final val ClassfileAnnotation: N = "ClassfileAnnotation"
-    final val ClassManifest: N       = "ClassManifest"
-    final val Enum: N                = "Enum"
-    final val Group: N               = "Group"
-    final val Tree: N                = "Tree"
-    final val Type : N               = "Type"
-    final val TypeTree: N            = "TypeTree"
+    final val BYNAME_PARAM_CLASS: N             = n("<byname>")
+    final val EQUALS_PATTERN: N                 = n("<equals>")
+    final val LOCAL_CHILD: N                    = n("<local child>")
+    final val REPEATED_PARAM_CLASS: N           = n("<repeated>")
+    final val WILDCARD_STAR: N                  = n("_*")
+    final val REIFY_TREECREATOR_PREFIX: N       = n("$treecreator")
+    final val REIFY_TYPECREATOR_PREFIX: N       = n("$typecreator")
+
+    final val Any: N                 = n("Any")
+    final val AnyVal: N              = n("AnyVal")
+    final val ExprApi: N             = n("ExprApi")
+    final val Mirror: N              = n("Mirror")
+    final val Nothing: N             = n("Nothing")
+    final val Null: N                = n("Null")
+    final val Object: N              = n("Object")
+    final val PartialFunction: N     = n("PartialFunction")
+    final val PrefixType: N          = n("PrefixType")
+    final val Serializable: N        = n("Serializable")
+    final val Singleton: N           = n("Singleton")
+    final val Throwable: N           = n("Throwable")
+
+    final val ClassfileAnnotation: N = n("ClassfileAnnotation")
+    final val ClassManifest: N       = n("ClassManifest")
+    final val Enum: N                = n("Enum")
+    final val Group: N               = n("Group")
+    final val Tree: N                = n("Tree")
+    final val Type : N               = n("Type")
+    final val TypeTree: N            = n("TypeTree")
 
     // Annotation simple names, used in Namer
-    final val BeanPropertyAnnot: N = "BeanProperty"
-    final val BooleanBeanPropertyAnnot: N = "BooleanBeanProperty"
-    final val bridgeAnnot: N = "bridge"
+    final val BeanPropertyAnnot: N = n("BeanProperty")
+    final val BooleanBeanPropertyAnnot: N = n("BooleanBeanProperty")
+    final val bridgeAnnot: N = n("bridge")
 
     // Classfile Attributes
-    final val AnnotationDefaultATTR: N      = "AnnotationDefault"
-    final val BridgeATTR: N                 = "Bridge"
-    final val ClassfileAnnotationATTR: N    = "RuntimeInvisibleAnnotations" // RetentionPolicy.CLASS. Currently not used (Apr 2009).
-    final val CodeATTR: N                   = "Code"
-    final val ConstantValueATTR: N          = "ConstantValue"
-    final val DeprecatedATTR: N             = "Deprecated"
-    final val ExceptionsATTR: N             = "Exceptions"
-    final val InnerClassesATTR: N           = "InnerClasses"
-    final val LineNumberTableATTR: N        = "LineNumberTable"
-    final val LocalVariableTableATTR: N     = "LocalVariableTable"
-    final val RuntimeAnnotationATTR: N      = "RuntimeVisibleAnnotations"   // RetentionPolicy.RUNTIME
-    final val RuntimeParamAnnotationATTR: N = "RuntimeVisibleParameterAnnotations" // RetentionPolicy.RUNTIME (annotations on parameters)
-    final val ScalaATTR: N                  = "Scala"
-    final val ScalaSignatureATTR: N         = "ScalaSig"
-    final val TASTYATTR: N                  = "TASTY"
-    final val SignatureATTR: N              = "Signature"
-    final val SourceFileATTR: N             = "SourceFile"
-    final val SyntheticATTR: N              = "Synthetic"
-
+    final val AnnotationDefaultATTR: N      = n("AnnotationDefault")
+    final val BridgeATTR: N                 = n("Bridge")
+    final val ClassfileAnnotationATTR: N    = n("RuntimeInvisibleAnnotations") // RetentionPolicy.CLASS. Currently not used (Apr 2009).
+    final val CodeATTR: N                   = n("Code")
+    final val ConstantValueATTR: N          = n("ConstantValue")
+    final val DeprecatedATTR: N             = n("Deprecated")
+    final val ExceptionsATTR: N             = n("Exceptions")
+    final val InnerClassesATTR: N           = n("InnerClasses")
+    final val LineNumberTableATTR: N        = n("LineNumberTable")
+    final val LocalVariableTableATTR: N     = n("LocalVariableTable")
+    final val RuntimeAnnotationATTR: N      = n("RuntimeVisibleAnnotations")   // RetentionPolicy.RUNTIME
+    final val RuntimeParamAnnotationATTR: N = n("RuntimeVisibleParameterAnnotations") // RetentionPolicy.RUNTIME (annotations on parameters)
+    final val ScalaATTR: N                  = n("Scala")
+    final val ScalaSignatureATTR: N         = n("ScalaSig")
+    final val TASTYATTR: N                  = n("TASTY")
+    final val SignatureATTR: N              = n("Signature")
+    final val SourceFileATTR: N             = n("SourceFile")
+    final val SyntheticATTR: N              = n("Synthetic")
 
 // ----- Term names -----------------------------------------
 
     // Compiler-internal
-    val ANYname: N                  = "<anyname>"
-    val CONSTRUCTOR: N              = "<init>"
-    val STATIC_CONSTRUCTOR: N       = "<clinit>"
-    val DEFAULT_CASE: N             = "defaultCase$"
-    val EVT2U: N                    = "evt2u$"
-    val EQEQ_LOCAL_VAR: N           = "eqEqTemp$"
-    val FAKE_LOCAL_THIS: N          = "this$"
-    val LAZY_FIELD_OFFSET: N        = "OFFSET$"
-    val LAZY_SLOW_SUFFIX: N         = "$lzycompute"
-    val UNIVERSE_BUILD_PREFIX: N    = "$u.build."
-    val UNIVERSE_BUILD: N           = "$u.build"
-    val UNIVERSE_PREFIX: N          = "$u."
-    val UNIVERSE_SHORT: N           = "$u"
-    val MIRROR_PREFIX: N            = "$m."
-    val MIRROR_SHORT: N             = "$m"
-    val MIRROR_UNTYPED: N           = "$m$untyped"
-    val REIFY_FREE_PREFIX: N        = "free$"
-    val REIFY_FREE_THIS_SUFFIX: N   = "$this"
-    val REIFY_FREE_VALUE_SUFFIX: N  = "$value"
-    val REIFY_SYMDEF_PREFIX: N      = "symdef$"
-    val OUTER: N                    = "$outer"
-    val REFINE_CLASS: N             = "<refinement>"
-    val ROOTPKG: N                  = "_root_"
-    val SELECTOR_DUMMY: N           = "<unapply-selector>"
-    val SELF: N                     = "$this"
-    val SKOLEM: N                   = "<skolem>"
-    val SPECIALIZED_INSTANCE: N     = "specInstance$"
-    val THIS: N                     = "_$this"
-    val TRAIT_CONSTRUCTOR: N        = "$init$"
-    val U2EVT: N                    = "u2evt$"
-    val ALLARGS: N                  = "$allArgs"
-
-    final val Nil: N                = "Nil"
-    final val Predef: N             = "Predef"
-    final val ScalaRunTime: N       = "ScalaRunTime"
-    final val Some: N               = "Some"
-
-    val x_0 : N  = "x$0"
-    val x_1 : N  = "x$1"
-    val x_2 : N  = "x$2"
-    val x_3 : N  = "x$3"
-    val x_4 : N  = "x$4"
-    val x_5 : N  = "x$5"
-    val x_6 : N  = "x$6"
-    val x_7 : N  = "x$7"
-    val x_8 : N  = "x$8"
-    val x_9 : N  = "x$9"
-    val _1 : N  = "_1"
-    val _2 : N  = "_2"
-    val _3 : N  = "_3"
-    val _4 : N  = "_4"
-    val _5 : N  = "_5"
-    val _6 : N  = "_6"
-    val _7 : N  = "_7"
-    val _8 : N  = "_8"
-    val _9 : N  = "_9"
-    val _10 : N = "_10"
-    val _11 : N = "_11"
-    val _12 : N = "_12"
-    val _13 : N = "_13"
-    val _14 : N = "_14"
-    val _15 : N = "_15"
-    val _16 : N = "_16"
-    val _17 : N = "_17"
-    val _18 : N = "_18"
-    val _19 : N = "_19"
-    val _20 : N = "_20"
-    val _21 : N = "_21"
-    val _22 : N = "_22"
-
-    val ??? : N = "???"
-
-    val genericWrapArray: N     = "genericWrapArray"
-    def wrapRefArray: N         = "wrapRefArray"
-    def wrapXArray(clsName: Name): N = "wrap" + clsName + "Array"
+    val ANYname: N                  = n("<anyname>")
+    val CONSTRUCTOR: N              = n("<init>")
+    val STATIC_CONSTRUCTOR: N       = n("<clinit>")
+    val DEFAULT_CASE: N             = n("defaultCase$")
+    val EVT2U: N                    = n("evt2u$")
+    val EQEQ_LOCAL_VAR: N           = n("eqEqTemp$")
+    val FAKE_LOCAL_THIS: N          = n("this$")
+    val LAZY_FIELD_OFFSET: N        = n("OFFSET$")
+    val LAZY_SLOW_SUFFIX: N         = n("$lzycompute")
+    val UNIVERSE_BUILD_PREFIX: N    = n("$u.build.")
+    val UNIVERSE_BUILD: N           = n("$u.build")
+    val UNIVERSE_PREFIX: N          = n("$u.")
+    val UNIVERSE_SHORT: N           = n("$u")
+    val MIRROR_PREFIX: N            = n("$m.")
+    val MIRROR_SHORT: N             = n("$m")
+    val MIRROR_UNTYPED: N           = n("$m$untyped")
+    val REIFY_FREE_PREFIX: N        = n("free$")
+    val REIFY_FREE_THIS_SUFFIX: N   = n("$this")
+    val REIFY_FREE_VALUE_SUFFIX: N  = n("$value")
+    val REIFY_SYMDEF_PREFIX: N      = n("symdef$")
+    val OUTER: N                    = n("$outer")
+    val REFINE_CLASS: N             = n("<refinement>")
+    val ROOTPKG: N                  = n("_root_")
+    val SELECTOR_DUMMY: N           = n("<unapply-selector>")
+    val SELF: N                     = n("$this")
+    val SKOLEM: N                   = n("<skolem>")
+    val SPECIALIZED_INSTANCE: N     = n("specInstance$")
+    val THIS: N                     = n("_$this")
+    val TRAIT_CONSTRUCTOR: N        = n("$init$")
+    val U2EVT: N                    = n("u2evt$")
+    val ALLARGS: N                  = n("$allArgs")
+
+    final val Nil: N                = n("Nil")
+    final val Predef: N             = n("Predef")
+    final val ScalaRunTime: N       = n("ScalaRunTime")
+    final val Some: N               = n("Some")
+
+    val x_0 : N  = n("x$0")
+    val x_1 : N  = n("x$1")
+    val x_2 : N  = n("x$2")
+    val x_3 : N  = n("x$3")
+    val x_4 : N  = n("x$4")
+    val x_5 : N  = n("x$5")
+    val x_6 : N  = n("x$6")
+    val x_7 : N  = n("x$7")
+    val x_8 : N  = n("x$8")
+    val x_9 : N  = n("x$9")
+    val _1 : N   = n("_1")
+    val _2 : N   = n("_2")
+    val _3 : N   = n("_3")
+    val _4 : N   = n("_4")
+    val _5 : N   = n("_5")
+    val _6 : N   = n("_6")
+    val _7 : N   = n("_7")
+    val _8 : N   = n("_8")
+    val _9 : N   = n("_9")
+    val _10 : N  = n("_10")
+    val _11 : N  = n("_11")
+    val _12 : N  = n("_12")
+    val _13 : N  = n("_13")
+    val _14 : N  = n("_14")
+    val _15 : N  = n("_15")
+    val _16 : N  = n("_16")
+    val _17 : N  = n("_17")
+    val _18 : N  = n("_18")
+    val _19 : N  = n("_19")
+    val _20 : N  = n("_20")
+    val _21 : N  = n("_21")
+    val _22 : N  = n("_22")
+
+    val ??? : N = n("???")
+
+    val genericWrapArray: N     = n("genericWrapArray")
+    def wrapRefArray: N         = n("wrapRefArray")
+    def wrapXArray(clsName: Name): N = n("wrap" + clsName + "Array")
 
     // Compiler utilized names
 
-    val AnnotatedType: N        = "AnnotatedType"
-    val AppliedTypeTree: N      = "AppliedTypeTree"
-    val ArrayAnnotArg: N        = "ArrayAnnotArg"
-    val Constant: N             = "Constant"
-    val ConstantType: N         = "ConstantType"
-    val doubleHash: N           = "doubleHash"
-    val ExistentialTypeTree: N  = "ExistentialTypeTree"
-    val Flag : N                = "Flag"
-    val floatHash: N            = "floatHash"
-    val Ident: N                = "Ident"
-    val Import: N               = "Import"
-    val Literal: N              = "Literal"
-    val LiteralAnnotArg: N      = "LiteralAnnotArg"
-    val longHash: N             = "longHash"
-    val Modifiers: N            = "Modifiers"
-    val NestedAnnotArg: N       = "NestedAnnotArg"
-    val NoFlags: N              = "NoFlags"
-    val NoPrefix: N             = "NoPrefix"
-    val NoSymbol: N             = "NoSymbol"
-    val NoType: N               = "NoType"
-    val Pair: N                 = "Pair"
-    val Ref: N                  = "Ref"
-    val RootPackage: N          = "RootPackage"
-    val RootClass: N            = "RootClass"
-    val Scala2: N               = "Scala2"
-    val Select: N               = "Select"
-    val StringContext: N        = "StringContext"
-    val This: N                 = "This"
-    val ThisType: N             = "ThisType"
-    val Tuple2: N               = "Tuple2"
-    val TYPE_ : N               = "TYPE"
-    val TypeApply: N            = "TypeApply"
-    val TypeRef: N              = "TypeRef"
-    val UNIT : N                = "UNIT"
-    val add_ : N                = "add"
-    val annotation: N           = "annotation"
-    val anyHash: N              = "anyHash"
-    val anyValClass: N          = "anyValClass"
-    val append: N               = "append"
-    val apply: N                = "apply"
-    val applyDynamic: N         = "applyDynamic"
-    val applyDynamicNamed: N    = "applyDynamicNamed"
-    val applyOrElse: N          = "applyOrElse"
-    val args : N                = "args"
-    val argv : N                = "argv"
-    val arrayClass: N           = "arrayClass"
-    val arrayElementClass: N    = "arrayElementClass"
-    val arrayValue: N           = "arrayValue"
-    val array_apply : N         = "array_apply"
-    val array_clone : N         = "array_clone"
-    val array_length : N        = "array_length"
-    val array_update : N        = "array_update"
-    val arraycopy: N            = "arraycopy"
-    val asTerm: N               = "asTerm"
-    val asModule: N             = "asModule"
-    val asMethod: N             = "asMethod"
-    val asType: N               = "asType"
-    val asClass: N              = "asClass"
-    val asInstanceOf_ : N       = "asInstanceOf"
-    val assert_ : N             = "assert"
-    val assume_ : N             = "assume"
-    val box: N                  = "box"
-    val build : N               = "build"
-    val bytes: N                = "bytes"
-    val canEqual_ : N           = "canEqual"
-    val cbnArg: N               = "<cbn-arg>"
-    val checkInitialized: N     = "checkInitialized"
-    val ClassManifestFactory: N = "ClassManifestFactory"
-    val classOf: N              = "classOf"
-    val clone_ : N              = "clone"
- //   val conforms : N             = "conforms" // Dotty deviation: no special treatment of conforms, so the occurrence of the name here would cause to unintended implicit shadowing. Should find a less common name for it in Predef.
-    val copy: N                 = "copy"
-    val currentMirror: N        = "currentMirror"
-    val create: N               = "create"
-    val definitions: N          = "definitions"
-    val delayedInit: N          = "delayedInit"
-    val delayedInitArg: N       = "delayedInit$body"
-    val drop: N                 = "drop"
-    val dynamics: N             = "dynamics"
-    val elem: N                 = "elem"
-    val emptyValDef: N          = "emptyValDef"
-    val ensureAccessible : N    = "ensureAccessible"
-    val enumTag: N              = "enumTag"
-    val eq: N                   = "eq"
-    val eqInstance: N           = "eqInstance"
-    val equalsNumChar : N       = "equalsNumChar"
-    val equalsNumNum : N        = "equalsNumNum"
-    val equalsNumObject : N     = "equalsNumObject"
-    val equals_ : N             = "equals"
-    val error: N                = "error"
-    val eval: N                 = "eval"
-    val eqAny: N                = "eqAny"
-    val ex: N                   = "ex"
-    val experimental: N         = "experimental"
-    val f: N                    = "f"
-    val false_ : N              = "false"
-    val filter: N               = "filter"
-    val finalize_ : N           = "finalize"
-    val find_ : N               = "find"
-    val flagsFromBits : N       = "flagsFromBits"
-    val flatMap: N              = "flatMap"
-    val foreach: N              = "foreach"
-    val genericArrayOps: N      = "genericArrayOps"
-    val get: N                  = "get"
-    val getClass_ : N           = "getClass"
-    val getOrElse: N            = "getOrElse"
-    val hasNext: N              = "hasNext"
-    val hashCode_ : N           = "hashCode"
-    val hash_ : N               = "hash"
-    val head: N                 = "head"
-    val higherKinds: N          = "higherKinds"
-    val identity: N             = "identity"
-    val implicitly: N           = "implicitly"
-    val in: N                   = "in"
-    val info: N                 = "info"
-    val inlinedEquals: N        = "inlinedEquals"
-    val isArray: N              = "isArray"
-    val isDefinedAt: N          = "isDefinedAt"
-    val isDefinedAtImpl: N      = "$isDefinedAt"
-    val isDefined: N            = "isDefined"
-    val isEmpty: N              = "isEmpty"
-    val isInstanceOf_ : N       = "isInstanceOf"
-    val isInstanceOfPM: N       = "$isInstanceOf$"
-    val java: N                 = "java"
-    val key: N                  = "key"
-    val lang: N                 = "lang"
-    val length: N               = "length"
-    val lengthCompare: N        = "lengthCompare"
-    val `macro` : N             = "macro"
-    val macroThis : N           = "_this"
-    val macroContext : N        = "c"
-    val main: N                 = "main"
-    val manifest: N             = "manifest"
-    val ManifestFactory: N      = "ManifestFactory"
-    val manifestToTypeTag: N    = "manifestToTypeTag"
-    val map: N                  = "map"
-    val materializeClassTag: N  = "materializeClassTag"
-    val materializeWeakTypeTag: N = "materializeWeakTypeTag"
-    val materializeTypeTag: N   = "materializeTypeTag"
-    val mirror : N              = "mirror"
-    val moduleClass : N         = "moduleClass"
-    val name: N                 = "name"
-    val ne: N                   = "ne"
-    val newFreeTerm: N          = "newFreeTerm"
-    val newFreeType: N          = "newFreeType"
-    val newScopeWith: N         = "newScopeWith"
-    val next: N                 = "next"
-    val nmeNewTermName: N       = "newTermName"
-    val nmeNewTypeName: N       = "newTypeName"
-    val noAutoTupling: N        = "noAutoTupling"
-    val normalize: N            = "normalize"
-    val notifyAll_ : N          = "notifyAll"
-    val notify_ : N             = "notify"
-    val null_ : N               = "null"
-    val ofDim: N                = "ofDim"
-    val origin: N               = "origin"
-    val prefix : N              = "prefix"
-    val productArity: N         = "productArity"
-    val productElement: N       = "productElement"
-    val productIterator: N      = "productIterator"
-    val productPrefix: N        = "productPrefix"
-    val readResolve: N          = "readResolve"
-    val reflect : N             = "reflect"
-    val reify : N               = "reify"
-    val rootMirror : N          = "rootMirror"
-    val run: N                  = "run"
-    val runOrElse: N            = "runOrElse"
-    val runtime: N              = "runtime"
-    val runtimeClass: N         = "runtimeClass"
-    val runtimeMirror: N        = "runtimeMirror"
-    val sameElements: N         = "sameElements"
-    val scala_ : N              = "scala"
-    val scalaShadowing : N      = "scalaShadowing"
-    val selectDynamic: N        = "selectDynamic"
-    val selectDynamicMethod: N  = "selectDynamicMethod"
-    val selectOverloadedMethod: N = "selectOverloadedMethod"
-    val selectTerm: N           = "selectTerm"
-    val selectType: N           = "selectType"
-    val self: N                 = "self"
-    val seqToArray: N           = "seqToArray"
-    val setAccessible: N        = "setAccessible"
-    val setAnnotations: N       = "setAnnotations"
-    val setSymbol: N            = "setSymbol"
-    val setType: N              = "setType"
-    val setTypeSignature: N     = "setTypeSignature"
-    val splice: N               = "splice"
-    val staticClass : N         = "staticClass"
-    val staticModule : N        = "staticModule"
-    val staticPackage : N       = "staticPackage"
-    val strictEquality: N       = "strictEquality"
-    val synchronized_ : N       = "synchronized"
-    val tag: N                  = "tag"
-    val tail: N                 = "tail"
-    val `then` : N              = "then"
-    val this_ : N               = "this"
-    val thisPrefix : N          = "thisPrefix"
-    val throw_ : N              = "throw"
-    val toArray: N              = "toArray"
-    val toList: N               = "toList"
-    val toObjectArray : N       = "toObjectArray"
-    val toSeq: N                = "toSeq"
-    val toString_ : N           = "toString"
-    val toTypeConstructor: N    = "toTypeConstructor"
-    val tpe : N                 = "tpe"
-    val tree : N                = "tree"
-    val true_ : N               = "true"
-    val typedProductIterator: N = "typedProductIterator"
-    val typeTagToManifest: N    = "typeTagToManifest"
-    val unapply: N              = "unapply"
-    val unapplySeq: N           = "unapplySeq"
-    val unbox: N                = "unbox"
-    val universe: N             = "universe"
-    val update: N               = "update"
-    val updateDynamic: N        = "updateDynamic"
-    val value: N                = "value"
-    val valueOf : N             = "valueOf"
-    val values: N               = "values"
-    val view_ : N               = "view"
-    val wait_ : N               = "wait"
-    val withFilter: N           = "withFilter"
-    val withFilterIfRefutable: N = "withFilterIfRefutable$"
-    val wrap: N                 = "wrap"
-    val zero: N                 = "zero"
-    val zip: N                  = "zip"
-    val nothingRuntimeClass: N  = "scala.runtime.Nothing$"
-    val nullRuntimeClass: N     = "scala.runtime.Null$"
-
-    val synthSwitch: N          = "$synthSwitch"
-    val _scope: N               = "$scope"
-
-    val nothingClass: N         = "Nothing$"
-    val nullClass: N            = "Null$"
+    val AnnotatedType: N          = n("AnnotatedType")
+    val AppliedTypeTree: N        = n("AppliedTypeTree")
+    val ArrayAnnotArg: N          = n("ArrayAnnotArg")
+    val Constant: N               = n("Constant")
+    val ConstantType: N           = n("ConstantType")
+    val doubleHash: N             = n("doubleHash")
+    val ExistentialTypeTree: N    = n("ExistentialTypeTree")
+    val Flag : N                  = n("Flag")
+    val floatHash: N              = n("floatHash")
+    val Ident: N                  = n("Ident")
+    val Import: N                 = n("Import")
+    val Literal: N                = n("Literal")
+    val LiteralAnnotArg: N        = n("LiteralAnnotArg")
+    val longHash: N               = n("longHash")
+    val Modifiers: N              = n("Modifiers")
+    val NestedAnnotArg: N         = n("NestedAnnotArg")
+    val NoFlags: N                = n("NoFlags")
+    val NoPrefix: N               = n("NoPrefix")
+    val NoSymbol: N               = n("NoSymbol")
+    val NoType: N                 = n("NoType")
+    val Pair: N                   = n("Pair")
+    val Ref: N                    = n("Ref")
+    val RootPackage: N            = n("RootPackage")
+    val RootClass: N              = n("RootClass")
+    val Scala2: N                 = n("Scala2")
+    val Select: N                 = n("Select")
+    val StringContext: N          = n("StringContext")
+    val This: N                   = n("This")
+    val ThisType: N               = n("ThisType")
+    val Tuple2: N                 = n("Tuple2")
+    val TYPE_ : N                 = n("TYPE")
+    val TypeApply: N              = n("TypeApply")
+    val TypeRef: N                = n("TypeRef")
+    val UNIT : N                  = n("UNIT")
+    val add_ : N                  = n("add")
+    val annotation: N             = n("annotation")
+    val anyHash: N                = n("anyHash")
+    val anyValClass: N            = n("anyValClass")
+    val append: N                 = n("append")
+    val apply: N                  = n("apply")
+    val applyDynamic: N           = n("applyDynamic")
+    val applyDynamicNamed: N      = n("applyDynamicNamed")
+    val applyOrElse: N            = n("applyOrElse")
+    val args : N                  = n("args")
+    val argv : N                  = n("argv")
+    val arrayClass: N             = n("arrayClass")
+    val arrayElementClass: N      = n("arrayElementClass")
+    val arrayValue: N             = n("arrayValue")
+    val array_apply : N           = n("array_apply")
+    val array_clone : N           = n("array_clone")
+    val array_length : N          = n("array_length")
+    val array_update : N          = n("array_update")
+    val arraycopy: N              = n("arraycopy")
+    val asTerm: N                 = n("asTerm")
+    val asModule: N               = n("asModule")
+    val asMethod: N               = n("asMethod")
+    val asType: N                 = n("asType")
+    val asClass: N                = n("asClass")
+    val asInstanceOf_ : N         = n("asInstanceOf")
+    val assert_ : N               = n("assert")
+    val assume_ : N               = n("assume")
+    val box: N                    = n("box")
+    val build : N                 = n("build")
+    val bytes: N                  = n("bytes")
+    val canEqual_ : N             = n("canEqual")
+    val cbnArg: N                 = n("<cbn-arg>")
+    val checkInitialized: N       = n("checkInitialized")
+    val ClassManifestFactory: N   = n("ClassManifestFactory")
+    val classOf: N                = n("classOf")
+    val clone_ : N                = n("clone")
+    val conforms_ : N             = n("conforms")
+    val copy: N                   = n("copy")
+    val currentMirror: N          = n("currentMirror")
+    val create: N                 = n("create")
+    val definitions: N            = n("definitions")
+    val delayedInit: N            = n("delayedInit")
+    val delayedInitArg: N         = n("delayedInit$body")
+    val drop: N                   = n("drop")
+    val dynamics: N               = n("dynamics")
+    val elem: N                   = n("elem")
+    val emptyValDef: N            = n("emptyValDef")
+    val ensureAccessible : N      = n("ensureAccessible")
+    val enumTag: N                = n("enumTag")
+    val eq: N                     = n("eq")
+    val eqInstance: N             = n("eqInstance")
+    val equalsNumChar : N         = n("equalsNumChar")
+    val equalsNumNum : N          = n("equalsNumNum")
+    val equalsNumObject : N       = n("equalsNumObject")
+    val equals_ : N               = n("equals")
+    val error: N                  = n("error")
+    val eval: N                   = n("eval")
+    val eqAny: N                  = n("eqAny")
+    val ex: N                     = n("ex")
+    val experimental: N           = n("experimental")
+    val f: N                      = n("f")
+    val false_ : N                = n("false")
+    val filter: N                 = n("filter")
+    val finalize_ : N             = n("finalize")
+    val find_ : N                 = n("find")
+    val flagsFromBits : N         = n("flagsFromBits")
+    val flatMap: N                = n("flatMap")
+    val foreach: N                = n("foreach")
+    val genericArrayOps: N        = n("genericArrayOps")
+    val get: N                    = n("get")
+    val getClass_ : N             = n("getClass")
+    val getOrElse: N              = n("getOrElse")
+    val hasNext: N                = n("hasNext")
+    val hashCode_ : N             = n("hashCode")
+    val hash_ : N                 = n("hash")
+    val head: N                   = n("head")
+    val higherKinds: N            = n("higherKinds")
+    val identity: N               = n("identity")
+    val implicitly: N             = n("implicitly")
+    val in: N                     = n("in")
+    val info: N                   = n("info")
+    val inlinedEquals: N          = n("inlinedEquals")
+    val isArray: N                = n("isArray")
+    val isDefinedAt: N            = n("isDefinedAt")
+    val isDefinedAtImpl: N        = n("$isDefinedAt")
+    val isDefined: N              = n("isDefined")
+    val isEmpty: N                = n("isEmpty")
+    val isInstanceOf_ : N         = n("isInstanceOf")
+    val isInstanceOfPM: N         = n("$isInstanceOf$")
+    val java: N                   = n("java")
+    val key: N                    = n("key")
+    val lang: N                   = n("lang")
+    val length: N                 = n("length")
+    val lengthCompare: N          = n("lengthCompare")
+    val `macro` : N               = n("macro")
+    val macroThis : N             = n("_this")
+    val macroContext : N          = n("c")
+    val main: N                   = n("main")
+    val manifest: N               = n("manifest")
+    val ManifestFactory: N        = n("ManifestFactory")
+    val manifestToTypeTag: N      = n("manifestToTypeTag")
+    val map: N                    = n("map")
+    val materializeClassTag: N    = n("materializeClassTag")
+    val materializeWeakTypeTag: N = n("materializeWeakTypeTag")
+    val materializeTypeTag: N     = n("materializeTypeTag")
+    val mirror : N                = n("mirror")
+    val moduleClass : N           = n("moduleClass")
+    val name: N                   = n("name")
+    val ne: N                     = n("ne")
+    val newFreeTerm: N            = n("newFreeTerm")
+    val newFreeType: N            = n("newFreeType")
+    val newScopeWith: N           = n("newScopeWith")
+    val next: N                   = n("next")
+    val nmeNewTermName: N         = n("newTermName")
+    val nmeNewTypeName: N         = n("newTypeName")
+    val noAutoTupling: N          = n("noAutoTupling")
+    val normalize: N              = n("normalize")
+    val notifyAll_ : N            = n("notifyAll")
+    val notify_ : N               = n("notify")
+    val null_ : N                 = n("null")
+    val ofDim: N                  = n("ofDim")
+    val origin: N                 = n("origin")
+    val prefix : N                = n("prefix")
+    val productArity: N           = n("productArity")
+    val productElement: N         = n("productElement")
+    val productIterator: N        = n("productIterator")
+    val productPrefix: N          = n("productPrefix")
+    val readResolve: N            = n("readResolve")
+    val reflect : N               = n("reflect")
+    val reify : N                 = n("reify")
+    val rootMirror : N            = n("rootMirror")
+    val run: N                    = n("run")
+    val runOrElse: N              = n("runOrElse")
+    val runtime: N                = n("runtime")
+    val runtimeClass: N           = n("runtimeClass")
+    val runtimeMirror: N          = n("runtimeMirror")
+    val sameElements: N           = n("sameElements")
+    val scala_ : N                = n("scala")
+    val scalaShadowing : N        = n("scalaShadowing")
+    val selectDynamic: N          = n("selectDynamic")
+    val selectDynamicMethod: N    = n("selectDynamicMethod")
+    val selectOverloadedMethod: N = n("selectOverloadedMethod")
+    val selectTerm: N             = n("selectTerm")
+    val selectType: N             = n("selectType")
+    val self: N                   = n("self")
+    val seqToArray: N             = n("seqToArray")
+    val setAccessible: N          = n("setAccessible")
+    val setAnnotations: N         = n("setAnnotations")
+    val setSymbol: N              = n("setSymbol")
+    val setType: N                = n("setType")
+    val setTypeSignature: N       = n("setTypeSignature")
+    val splice: N                 = n("splice")
+    val staticClass : N           = n("staticClass")
+    val staticModule : N          = n("staticModule")
+    val staticPackage : N         = n("staticPackage")
+    val strictEquality: N         = n("strictEquality")
+    val synchronized_ : N         = n("synchronized")
+    val tag: N                    = n("tag")
+    val tail: N                   = n("tail")
+    val `then` : N                = n("then")
+    val this_ : N                 = n("this")
+    val thisPrefix : N            = n("thisPrefix")
+    val throw_ : N                = n("throw")
+    val toArray: N                = n("toArray")
+    val toList: N                 = n("toList")
+    val toObjectArray : N         = n("toObjectArray")
+    val toSeq: N                  = n("toSeq")
+    val toString_ : N             = n("toString")
+    val toTypeConstructor: N      = n("toTypeConstructor")
+    val tpe : N                   = n("tpe")
+    val tree : N                  = n("tree")
+    val true_ : N                 = n("true")
+    val typedProductIterator: N   = n("typedProductIterator")
+    val typeTagToManifest: N      = n("typeTagToManifest")
+    val unapply: N                = n("unapply")
+    val unapplySeq: N             = n("unapplySeq")
+    val unbox: N                  = n("unbox")
+    val universe: N               = n("universe")
+    val update: N                 = n("update")
+    val updateDynamic: N          = n("updateDynamic")
+    val value: N                  = n("value")
+    val valueOf : N               = n("valueOf")
+    val values: N                 = n("values")
+    val view_ : N                 = n("view")
+    val wait_ : N                 = n("wait")
+    val withFilter: N             = n("withFilter")
+    val withFilterIfRefutable: N  = n("withFilterIfRefutable$")
+    val wrap: N                   = n("wrap")
+    val zero: N                   = n("zero")
+    val zip: N                    = n("zip")
+    val nothingRuntimeClass: N    = n("scala.runtime.Nothing$")
+    val nullRuntimeClass: N       = n("scala.runtime.Null$")
+
+    val synthSwitch: N            = n("$synthSwitch")
+    val _scope: N                 = n("$scope")
+
+    val nothingClass: N           = n("Nothing$")
+    val nullClass: N              = n("Null$")
 
     val falseModuleClassNames = Set(nothingClass, nullClass, nothingRuntimeClass, nullRuntimeClass)
 
     // unencoded operators
     object raw {
-      final val AMP  : N  = "&"
-      final val BANG : N  = "!"
-      final val BAR  : N  = "|"
-      final val DOLLAR: N = "$"
-      final val GE: N     = ">="
-      final val LE: N     = "<="
-      final val MINUS: N  = "-"
-      final val NE: N     = "!="
-      final val PLUS : N  = "+"
-      final val SLASH: N  = "/"
-      final val STAR : N  = "*"
-      final val TILDE: N  = "~"
+      final val AMP  : N  = n("&")
+      final val BANG : N  = n("!")
+      final val BAR  : N  = n("|")
+      final val DOLLAR: N = n("$")
+      final val GE: N     = n(">=")
+      final val LE: N     = n("<=")
+      final val MINUS: N  = n("-")
+      final val NE: N     = n("!=")
+      final val PLUS : N  = n("+")
+      final val SLASH: N  = n("/")
+      final val STAR : N  = n("*")
+      final val TILDE: N  = n("~")
 
       final val isUnary: Set[Name] = Set(MINUS, PLUS, TILDE, BANG)
     }
 
     object specializedTypeNames {
-      final val Boolean: N = "Z"
-      final val Byte: N    = "B"
-      final val Char: N    = "C"
-      final val Short: N   = "S"
-      final val Int: N     = "I"
-      final val Long: N    = "J"
-      final val Float: N   = "F"
-      final val Double: N  = "D"
-      final val Void: N    = "V"
-      final val Object: N  = "L"
-
-      final val prefix: N = "$m"
-      final val separator: N = "c"
-      final val suffix: N = "$sp"
+      final val Boolean: N = n("Z")
+      final val Byte: N    = n("B")
+      final val Char: N    = n("C")
+      final val Short: N   = n("S")
+      final val Int: N     = n("I")
+      final val Long: N    = n("J")
+      final val Float: N   = n("F")
+      final val Double: N  = n("D")
+      final val Void: N    = n("V")
+      final val Object: N  = n("L")
+
+      final val prefix: N = n("$m")
+      final val separator: N = n("c")
+      final val suffix: N = n("$sp")
     }
 
     // value-conversion methods
-    val toByte: N   = "toByte"
-    val toShort: N  = "toShort"
-    val toChar: N   = "toChar"
-    val toInt: N    = "toInt"
-    val toLong: N   = "toLong"
-    val toFloat: N  = "toFloat"
-    val toDouble: N = "toDouble"
+    val toByte: N   = n("toByte")
+    val toShort: N  = n("toShort")
+    val toChar: N   = n("toChar")
+    val toInt: N    = n("toInt")
+    val toLong: N   = n("toLong")
+    val toFloat: N  = n("toFloat")
+    val toDouble: N = n("toDouble")
 
     // primitive operation methods for structural types mostly
     // overlap with the above, but not for these two.
-    val toCharacter: N = "toCharacter"
-    val toInteger: N   = "toInteger"
+    val toCharacter: N = n("toCharacter")
+    val toInteger: N   = n("toInteger")
 
     def newLazyValSlowComputeName(lzyValName: N) = lzyValName ++ LAZY_SLOW_SUFFIX
 
     // ASCII names for operators
-    val ADD      : N = "+"
-    val AND      : N = "&"
-    val ASR      : N = ">>"
-    val DIV      : N = "/"
-    val EQ       : N = "=="
-    val EQL      : N = "="
-    val GE       : N = ">="
-    val GT       : N = ">"
-    val HASHHASH : N = "##"
-    val LE       : N = "<="
-    val LSL      : N = "<<"
-    val LSR      : N = ">>>"
-    val LT       : N = "<"
-    val MINUS    : N = "-"
-    val MOD      : N = "%"
-    val MUL      : N = "*"
-    val NE       : N = "!="
-    val OR       : N = "|"
+    val ADD      : N = n("+")
+    val AND      : N = n("&")
+    val ASR      : N = n(">>")
+    val DIV      : N = n("/")
+    val EQ       : N = n("==")
+    val EQL      : N = n("=")
+    val GE       : N = n(">=")
+    val GT       : N = n(">")
+    val HASHHASH : N = n("##")
+    val LE       : N = n("<=")
+    val LSL      : N = n("<<")
+    val LSR      : N = n(">>>")
+    val LT       : N = n("<")
+    val MINUS    : N = n("-")
+    val MOD      : N = n("%")
+    val MUL      : N = n("*")
+    val NE       : N = n("!=")
+    val OR       : N = n("|")
     val PLUS     = ADD    // technically redundant, but ADD looks funny with MINUS
     val SUB      = MINUS  // ... as does SUB with PLUS
-    val XOR      : N = "^"
-    val ZAND     : N = "&&"
-    val ZOR      : N = "||"
+    val XOR      : N = n("^")
+    val ZAND     : N = n("&&")
+    val ZOR      : N = n("||")
 
     // unary operators
-    val UNARY_PREFIX: N = "unary_"
-    val UNARY_~ : N = "unary_~"
-    val UNARY_+ : N = "unary_+"
-    val UNARY_- : N = "unary_-"
-    val UNARY_! : N = "unary_!"
+    val UNARY_PREFIX: N = n("unary_")
+    val UNARY_~ : N = n("unary_~")
+    val UNARY_+ : N = n("unary_+")
+    val UNARY_- : N = n("unary_-")
+    val UNARY_! : N = n("unary_!")
 
     // Grouped here so Cleanup knows what tests to perform.
     val CommonOpNames   = Set[Name](OR, XOR, AND, EQ, NE)
@@ -652,36 +647,36 @@ object StdNames {
       ++ CommonOpNames
     )
 
-    val add: N                    = "add"
-    val complement: N             = "complement"
-    val divide: N                 = "divide"
-    val multiply: N               = "multiply"
-    val negate: N                 = "negate"
-    val positive: N               = "positive"
-    val shiftLogicalRight: N      = "shiftLogicalRight"
-    val shiftSignedLeft: N        = "shiftSignedLeft"
-    val shiftSignedRight: N       = "shiftSignedRight"
-    val subtract: N               = "subtract"
-    val takeAnd: N                = "takeAnd"
-    val takeConditionalAnd: N     = "takeConditionalAnd"
-    val takeConditionalOr: N      = "takeConditionalOr"
-    val takeModulo: N             = "takeModulo"
-    val takeNot: N                = "takeNot"
-    val takeOr: N                 = "takeOr"
-    val takeXor: N                = "takeXor"
-    val testEqual: N              = "testEqual"
-    val testGreaterOrEqualThan: N = "testGreaterOrEqualThan"
-    val testGreaterThan: N        = "testGreaterThan"
-    val testLessOrEqualThan: N    = "testLessOrEqualThan"
-    val testLessThan: N           = "testLessThan"
-    val testNotEqual: N           = "testNotEqual"
-
-    val isBoxedNumberOrBoolean: N = "isBoxedNumberOrBoolean"
-    val isBoxedNumber: N = "isBoxedNumber"
+    val add: N                    = n("add")
+    val complement: N             = n("complement")
+    val divide: N                 = n("divide")
+    val multiply: N               = n("multiply")
+    val negate: N                 = n("negate")
+    val positive: N               = n("positive")
+    val shiftLogicalRight: N      = n("shiftLogicalRight")
+    val shiftSignedLeft: N        = n("shiftSignedLeft")
+    val shiftSignedRight: N       = n("shiftSignedRight")
+    val subtract: N               = n("subtract")
+    val takeAnd: N                = n("takeAnd")
+    val takeConditionalAnd: N     = n("takeConditionalAnd")
+    val takeConditionalOr: N      = n("takeConditionalOr")
+    val takeModulo: N             = n("takeModulo")
+    val takeNot: N                = n("takeNot")
+    val takeOr: N                 = n("takeOr")
+    val takeXor: N                = n("takeXor")
+    val testEqual: N              = n("testEqual")
+    val testGreaterOrEqualThan: N = n("testGreaterOrEqualThan")
+    val testGreaterThan: N        = n("testGreaterThan")
+    val testLessOrEqualThan: N    = n("testLessOrEqualThan")
+    val testLessThan: N           = n("testLessThan")
+    val testNotEqual: N           = n("testNotEqual")
+
+    val isBoxedNumberOrBoolean: N = n("isBoxedNumberOrBoolean")
+    val isBoxedNumber: N = n("isBoxedNumber")
   }
 
   class ScalaTermNames extends ScalaNames[TermName] {
-    protected implicit def fromString(s: String): TermName = termName(s)
+    protected def n(s: String): TermName = termName(s)
 
     @switch def syntheticParamName(i: Int): TermName = i match {
       case 0  => x_0
@@ -728,12 +723,12 @@ object StdNames {
 
     def newBitmapName(bitmapPrefix: TermName, n: Int): TermName = bitmapPrefix ++ n.toString
 
-    def selectorName(n: Int): TermName = "_" + (n + 1)
+    def selectorName(x: Int): TermName = n("_" + (x + 1))
 
     object primitive {
-      val arrayApply: TermName  = "[]apply"
-      val arrayUpdate: TermName = "[]update"
-      val arrayLength: TermName = "[]length"
+      val arrayApply: TermName  = n("[]apply")
+      val arrayUpdate: TermName = n("[]update")
+      val arrayLength: TermName = n("[]length")
       val names: Set[Name] = Set(arrayApply, arrayUpdate, arrayLength)
     }
 
@@ -741,13 +736,13 @@ object StdNames {
   }
 
   class ScalaTypeNames extends ScalaNames[TypeName] {
-    protected implicit def fromString(s: String): TypeName = typeName(s)
+    protected def n(s: String): TypeName = typeName(s)
 
-    def syntheticTypeParamName(i: Int): TypeName = "X" + i
+    def syntheticTypeParamName(i: Int): TypeName = n("X" + i)
 
     final val Conforms = encode("<:<")
 
-    final val Uninstantiated: TypeName = "?$"
+    final val Uninstantiated: TypeName = n("?$")
   }
 
   abstract class JavaNames[N <: Name] extends DefinedNames[N] {
@@ -802,43 +797,43 @@ object StdNames {
     final val VOLATILEkw: N     = kw("volatile")
     final val WHILEkw: N        = kw("while")
 
-    final val BoxedBoolean: N       = "java.lang.Boolean"
-    final val BoxedByte: N          = "java.lang.Byte"
-    final val BoxedCharacter: N     = "java.lang.Character"
-    final val BoxedDouble: N        = "java.lang.Double"
-    final val BoxedFloat: N         = "java.lang.Float"
-    final val BoxedInteger: N       = "java.lang.Integer"
-    final val BoxedLong: N          = "java.lang.Long"
-    final val BoxedNumber: N        = "java.lang.Number"
-    final val BoxedShort: N         = "java.lang.Short"
-    final val Class: N              = "java.lang.Class"
-    final val IOOBException: N      = "java.lang.IndexOutOfBoundsException"
-    final val InvTargetException: N = "java.lang.reflect.InvocationTargetException"
-    final val MethodAsObject: N     = "java.lang.reflect.Method"
-    final val NPException: N        = "java.lang.NullPointerException"
-    final val Object: N             = "java.lang.Object"
-    final val String: N             = "java.lang.String"
-    final val Throwable: N          = "java.lang.Throwable"
-
-    final val ForName: N          = "forName"
-    final val GetCause: N         = "getCause"
-    final val GetClass: N         = "getClass"
-    final val GetClassLoader: N   = "getClassLoader"
-    final val GetComponentType: N = "getComponentType"
-    final val GetMethod: N        = "getMethod"
-    final val Invoke: N           = "invoke"
-    final val JavaLang: N         = "java.lang"
-
-    final val BeanProperty: N        = "scala.beans.BeanProperty"
-    final val BooleanBeanProperty: N = "scala.beans.BooleanBeanProperty"
-    final val JavaSerializable: N    = "java.io.Serializable"
+    final val BoxedBoolean: N       = n("java.lang.Boolean")
+    final val BoxedByte: N          = n("java.lang.Byte")
+    final val BoxedCharacter: N     = n("java.lang.Character")
+    final val BoxedDouble: N        = n("java.lang.Double")
+    final val BoxedFloat: N         = n("java.lang.Float")
+    final val BoxedInteger: N       = n("java.lang.Integer")
+    final val BoxedLong: N          = n("java.lang.Long")
+    final val BoxedNumber: N        = n("java.lang.Number")
+    final val BoxedShort: N         = n("java.lang.Short")
+    final val Class: N              = n("java.lang.Class")
+    final val IOOBException: N      = n("java.lang.IndexOutOfBoundsException")
+    final val InvTargetException: N = n("java.lang.reflect.InvocationTargetException")
+    final val MethodAsObject: N     = n("java.lang.reflect.Method")
+    final val NPException: N        = n("java.lang.NullPointerException")
+    final val Object: N             = n("java.lang.Object")
+    final val String: N             = n("java.lang.String")
+    final val Throwable: N          = n("java.lang.Throwable")
+
+    final val ForName: N          = n("forName")
+    final val GetCause: N         = n("getCause")
+    final val GetClass: N         = n("getClass")
+    final val GetClassLoader: N   = n("getClassLoader")
+    final val GetComponentType: N = n("getComponentType")
+    final val GetMethod: N        = n("getMethod")
+    final val Invoke: N           = n("invoke")
+    final val JavaLang: N         = n("java.lang")
+
+    final val BeanProperty: N        = n("scala.beans.BeanProperty")
+    final val BooleanBeanProperty: N = n("scala.beans.BooleanBeanProperty")
+    final val JavaSerializable: N    = n("java.io.Serializable")
    }
 
   class JavaTermNames extends JavaNames[TermName] {
-    protected def fromString(s: String): TermName = termName(s)
+    protected def n(s: String): TermName = termName(s)
   }
   class JavaTypeNames extends JavaNames[TypeName] {
-    protected def fromString(s: String): TypeName = typeName(s)
+    protected def n(s: String): TypeName = typeName(s)
   }
 
   val nme = new ScalaTermNames
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index 9b5d02854e57..d97c4698b7b8 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -126,7 +126,7 @@ object SymDenotations {
     final val name: Name,
     initFlags: FlagSet,
     initInfo: Type,
-    initPrivateWithin: Symbol = NoSymbol) extends SingleDenotation(symbol) {
+    initPrivateWithin: Symbol = NoSymbol) extends SingleDenotation(symbol, initInfo) {
 
     //assert(symbol.id != 4940, name)
 
@@ -142,7 +142,6 @@ object SymDenotations {
     // ------ Getting and setting fields -----------------------------
 
     private[this] var myFlags: FlagSet = adaptFlags(initFlags)
-    private[this] var myInfo: Type = initInfo
     private[this] var myPrivateWithin: Symbol = initPrivateWithin
     private[this] var myAnnotations: List[Annotation] = Nil
 
@@ -181,36 +180,40 @@ object SymDenotations {
         if (myInfo.isInstanceOf[SymbolLoader]) FromStartFlags
         else AfterLoadFlags)
 
-    /** Has this denotation one of the flags in `fs` set? */
+    /** Does this denotation have one of the flags in `fs` set? */
     final def is(fs: FlagSet)(implicit ctx: Context) =
       (if (isCurrent(fs)) myFlags else flags) is fs
 
-    /** Has this denotation one of the flags in `fs` set, whereas none of the flags
-     *  in `butNot` are set?
+    /** Does this denotation have at least one of the flags in `fs` set, and
+     *  none of the flags in `butNot` set?
      */
     final def is(fs: FlagSet, butNot: FlagSet)(implicit ctx: Context) =
-      (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags) is (fs, butNot)
+      (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags) is (fs, butNot = butNot)
 
-    /** Has this denotation all of the flags in `fs` set? */
-    final def is(fs: FlagConjunction)(implicit ctx: Context) =
-      (if (isCurrent(fs)) myFlags else flags) is fs
-
-    /** Has this denotation all of the flags in `fs` set, whereas none of the flags
-     *  in `butNot` are set?
+    /** Does this denotation have at least one of the flags in `fs` set,
+     *  and at least one of the flags in `and` set?
      */
-    final def is(fs: FlagConjunction, butNot: FlagSet)(implicit ctx: Context) =
-      (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags) is (fs, butNot)
+    final def isBoth(fs: FlagSet, and: FlagSet)(implicit ctx: Context) =
+       (if (isCurrent(fs) && isCurrent(and)) myFlags else flags) isBoth (fs, and)
 
-    /** The type info.
-     *  The info is an instance of TypeType iff this is a type denotation
-     *  Uncompleted denotations set myInfo to a LazyType.
+    /** Does this denotation have at least one of the flags in `fs` set,
+     *  and at least one of the flags in `and` set,
+     *  and none of the flags in `butNot` set?
      */
-    final def info(implicit ctx: Context): Type = {
-      def completeInfo = { // Written this way so that `info` is small enough to be inlined
-        completeFrom(myInfo.asInstanceOf[LazyType]); info
-      }
-      if (myInfo.isInstanceOf[LazyType]) completeInfo else myInfo
-    }
+    final def isBoth(fs: FlagSet, and: FlagSet, butNot: FlagSet)(implicit ctx: Context) =
+       (if (isCurrent(fs) && isCurrent(and) && isCurrent(butNot)) myFlags else flags) isBoth (fs, and = and, butNot = butNot)
+
+    /** A type parameter of a class or trait */
+    final def isClassTypeParam(implicit ctx: Context) =
+      isBoth(TypeParam, and = Private)
+
+    /** A Java interface, potentially with default methods */
+    final def isJavaTrait(implicit ctx: Context) =
+      is(JavaDefined) && is(Trait) && is(NoInits)
+
+    /** A parameter forwarder */
+    final def isParamForwarder(implicit ctx: Context) =
+      is(Method) && is(Stable) && is(ParamAccessor)
 
     /** The type info, or, if symbol is not yet completed, the completer */
     final def infoOrCompleter = myInfo
@@ -221,7 +224,7 @@ object SymDenotations {
       case _ => Some(myInfo)
     }
 
-    private def completeFrom(completer: LazyType)(implicit ctx: Context): Unit =
+    final def completeFrom(completer: LazyType)(implicit ctx: Context): Unit =
       if (Config.showCompletions) {
         println(i"${"  " * indent}completing ${if (isType) "type" else "val"} $name")
         indent += 1
@@ -782,7 +785,7 @@ object SymDenotations {
 
     def isSkolem: Boolean = name == nme.SKOLEM
 
-    def isInlineMethod(implicit ctx: Context): Boolean = is(InlineMethod, butNot = Accessor)
+    def isInlineMethod(implicit ctx: Context): Boolean = isBoth(Inline, and = Method, butNot = Accessor)
 
     /** ()T and => T types should be treated as equivalent for this symbol.
      *  Note: For the moment, we treat Scala-2 compiled symbols as loose matching,
@@ -1125,7 +1128,7 @@ object SymDenotations {
     final def accessBoundary(base: Symbol)(implicit ctx: Context): Symbol = {
       val fs = flags
       if (fs is Private) owner
-      else if (fs is StaticProtected) defn.RootClass
+      else if (fs.isBoth(Protected, and = JavaStatic)) defn.RootClass
       else if (privateWithin.exists && !ctx.phase.erasedTypes) privateWithin
       else if (fs is Protected) base
       else defn.RootClass
diff --git a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
index 40c3bce68592..bb305461884d 100644
--- a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
@@ -8,7 +8,7 @@ import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile }
 import classpath._
 import Contexts._, Symbols._, Flags._, SymDenotations._, Types._, Scopes._, util.Positions._, Names._
 import StdNames._, NameOps._
-import Decorators.{PreNamedString, StringInterpolators}
+import Decorators.{StringDecorator, StringInterpolators}
 import classfile.ClassfileParser
 import util.Stats
 import Decorators._
@@ -43,19 +43,19 @@ class SymbolLoaders {
   /** Enter class with given `name` into scope of `owner`.
    */
   def enterClass(
-      owner: Symbol, name: PreName, completer: SymbolLoader,
+      owner: Symbol, name: TypeName, completer: SymbolLoader,
       flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(implicit ctx: Context): Symbol = {
-    val cls = ctx.newClassSymbol(owner, name.toTypeName.unmangleClassName.decode, flags, completer, assocFile = completer.sourceFileOrNull)
+    val cls = ctx.newClassSymbol(owner, name.unmangleClassName.decode, flags, completer, assocFile = completer.sourceFileOrNull)
     enterNew(owner, cls, completer, scope)
   }
 
   /** Enter module with given `name` into scope of `owner`.
    */
   def enterModule(
-      owner: Symbol, name: PreName, completer: SymbolLoader,
+      owner: Symbol, name: TermName, completer: SymbolLoader,
       modFlags: FlagSet = EmptyFlags, clsFlags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(implicit ctx: Context): Symbol = {
     val module = ctx.newModuleSymbol(
-      owner, name.toTermName.decode, modFlags, clsFlags,
+      owner, name.decode, modFlags, clsFlags,
       (module, _) => completer.proxy withDecls newScope withSourceModule (_ => module),
       assocFile = completer.sourceFileOrNull)
     enterNew(owner, module, completer, scope)
@@ -95,11 +95,11 @@ class SymbolLoaders {
    *  and give them `completer` as type.
    */
   def enterClassAndModule(
-      owner: Symbol, name: PreName, completer: SymbolLoader,
+      owner: Symbol, name: Name, completer: SymbolLoader,
       flags: FlagSet = EmptyFlags, scope: Scope = EmptyScope)(implicit ctx: Context): Unit = {
-    val clazz = enterClass(owner, name, completer, flags, scope)
+    val clazz = enterClass(owner, name.toTypeName, completer, flags, scope)
     val module = enterModule(
-      owner, name, completer,
+      owner, name.toTermName, completer,
       modFlags = flags.toTermFlags & RetainedModuleValFlags,
       clsFlags = flags.toTypeFlags & RetainedModuleClassFlags,
       scope = scope)
@@ -115,7 +115,7 @@ class SymbolLoaders {
    *  All entered symbols are given a source completer of `src` as info.
    */
   def enterToplevelsFromSource(
-      owner: Symbol, name: PreName, src: AbstractFile,
+      owner: Symbol, name: TermName, src: AbstractFile,
       scope: Scope = EmptyScope)(implicit ctx: Context): Unit = {
 
     val completer = new SourcefileLoader(src)
@@ -183,12 +183,12 @@ class SymbolLoaders {
     ((classRep.binary, classRep.source): @unchecked) match {
       case (Some(bin), Some(src)) if needCompile(bin, src) && !binaryOnly(owner, classRep.name) =>
         if (ctx.settings.verbose.value) ctx.inform("[symloader] picked up newer source file for " + src.path)
-        enterToplevelsFromSource(owner, classRep.name, src)
+        enterToplevelsFromSource(owner, classRep.name.toTermName, src)
       case (None, Some(src)) =>
         if (ctx.settings.verbose.value) ctx.inform("[symloader] no class, picked up source file for " + src.path)
-        enterToplevelsFromSource(owner, classRep.name, src)
+        enterToplevelsFromSource(owner, classRep.name.toTermName, src)
       case (Some(bin), _) =>
-        enterClassAndModule(owner, classRep.name, ctx.platform.newClassLoader(bin))
+        enterClassAndModule(owner, classRep.name.toTermName, ctx.platform.newClassLoader(bin))
     }
   }
 
diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
index b7ea26776bd4..aa3e193131ea 100644
--- a/compiler/src/dotty/tools/dotc/core/Symbols.scala
+++ b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -222,8 +222,8 @@ trait Symbols { this: Context =>
   /** Define a new symbol associated with a Bind or pattern wildcard and
    *  make it gadt narrowable.
    */
-  def newPatternBoundSymbol(name: Name, info: Type, pos: Position) = {
-    val sym = newSymbol(owner, name, Case, info, coord = pos)
+  def newPatternBoundSymbol(name: Name, info: Type, coord: Coord) = {
+    val sym = newSymbol(owner, name, Case, info, coord = coord)
     if (name.isTypeName) gadt.setBounds(sym, info.bounds)
     sym
   }
@@ -309,11 +309,11 @@ trait Symbols { this: Context =>
   /** Create a new skolem symbol. This is not the same as SkolemType, even though the
    *  motivation (create a singleton referencing to a type) is similar.
    */
-  def newSkolem(tp: Type) = newSymbol(defn.RootClass, nme.SKOLEM, SyntheticArtifact | NonMember | Permanent, tp)
+  def newSkolem(tp: Type) = newSymbol(defn.RootClass, nme.SKOLEM, Synthetic | Artifact | NonMember | Permanent, tp)
 
   def newErrorSymbol(owner: Symbol, name: Name, msg: => Message) = {
     val errType = ErrorType(msg)
-    newSymbol(owner, name, SyntheticArtifact,
+    newSymbol(owner, name, Synthetic | Artifact,
         if (name.isTypeName) TypeAlias(errType) else errType)
   }
 
@@ -370,32 +370,38 @@ trait Symbols { this: Context =>
 
 // ----- Locating predefined symbols ----------------------------------------
 
-  def requiredPackage(path: PreName): TermSymbol =
-    base.staticRef(path.toTermName, isPackage = true).requiredSymbol(_ is Package).asTerm
+  def requiredPackage(path: TermName): TermSymbol =
+    base.staticRef(path, isPackage = true).requiredSymbol(_ is Package).asTerm
 
-  def requiredPackageRef(path: PreName): TermRef = requiredPackage(path).termRef
-
-  def requiredClass(path: PreName): ClassSymbol =
-    base.staticRef(path.toTypeName).requiredSymbol(_.isClass) match {
-      case cls: ClassSymbol => cls
-      case sym => defn.AnyClass
-    }
-
-  def requiredClassRef(path: PreName): TypeRef = requiredClass(path).typeRef
+  def requiredPackageRef(path: TermName): TermRef = requiredPackage(path).termRef
 
   /** Get ClassSymbol if class is either defined in current compilation run
    *  or present on classpath.
    *  Returns NoSymbol otherwise. */
-  def getClassIfDefined(path: PreName): Symbol =
-    base.staticRef(path.toTypeName, generateStubs = false).requiredSymbol(_.isClass, generateStubs = false)
+  def getClassIfDefined(path: TypeName): Symbol =
+    base.staticRef(path, generateStubs = false).requiredSymbol(_.isClass, generateStubs = false)
+
+  def requiredMethod(path: TermName): TermSymbol =
+    base.staticRef(path).requiredSymbol(_ is Method).asTerm
+
+  // The following 4 methods have an overloaded String version because of
+  // their extensive use in Definitions.scala.
+
+  def requiredClass(path: String): ClassSymbol = requiredClass(path.toTypeName)
+  def requiredClass(path: TypeName): ClassSymbol =
+    base.staticRef(path).requiredSymbol(_.isClass) match {
+      case cls: ClassSymbol => cls
+      case sym => defn.AnyClass
+    }
 
-  def requiredModule(path: PreName): TermSymbol =
-    base.staticRef(path.toTermName).requiredSymbol(_ is Module).asTerm
+  def requiredClassRef(path: String): TypeRef = requiredClass(path.toTypeName).typeRef
+  def requiredClassRef(path: TypeName): TypeRef = requiredClass(path).typeRef
 
-  def requiredModuleRef(path: PreName): TermRef = requiredModule(path).termRef
+  def requiredModule(path: String): TermSymbol = requiredModule(path.toTermName)
+  def requiredModule(path: TermName): TermSymbol = base.staticRef(path).requiredSymbol(_ is Module).asTerm
 
-  def requiredMethod(path: PreName): TermSymbol =
-    base.staticRef(path.toTermName).requiredSymbol(_ is Method).asTerm
+  def requiredModuleRef(path: String): TermRef = requiredModuleRef(path.toTermName)
+  def requiredModuleRef(path: TermName): TermRef = requiredModule(path).termRef
 }
 
 object Symbols {
@@ -604,12 +610,12 @@ object Symbols {
 
     def toText(printer: Printer): Text = printer.toText(this)
 
-    def showLocated(implicit ctx: Context): String = ctx.locatedText(this).show
-    def showExtendedLocation(implicit ctx: Context): String = ctx.extendedLocationText(this).show
-    def showDcl(implicit ctx: Context): String = ctx.dclText(this).show
-    def showKind(implicit ctx: Context): String = ctx.kindString(this)
-    def showName(implicit ctx: Context): String = ctx.nameString(this)
-    def showFullName(implicit ctx: Context): String = ctx.fullNameString(this)
+    def showLocated(implicit ctx: Context): String = ctx.printer.locatedText(this).show
+    def showExtendedLocation(implicit ctx: Context): String = ctx.printer.extendedLocationText(this).show
+    def showDcl(implicit ctx: Context): String = ctx.printer.dclText(this).show
+    def showKind(implicit ctx: Context): String = ctx.printer.kindString(this)
+    def showName(implicit ctx: Context): String = ctx.printer.nameString(this)
+    def showFullName(implicit ctx: Context): String = ctx.printer.fullNameString(this)
 
     override def hashCode() = id // for debugging.
   }
diff --git a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala b/compiler/src/dotty/tools/dotc/core/TypeApplications.scala
index 0eefd44b109e..ef886479b5ba 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeApplications.scala
@@ -154,10 +154,11 @@ object TypeApplications {
   }
 }
 
-import TypeApplications._
-
 /** A decorator that provides methods for modeling type application */
-class TypeApplications(val self: Type) extends AnyVal {
+trait TypeApplications extends Any {
+  def self: Type
+
+  import TypeApplications._
 
   /** The type parameters of this type are:
    *  For a ClassInfo type, the type parameters of its class.
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index c85cbcdf2622..be36c8bf92d2 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -134,7 +134,7 @@ object Types {
     }
 
     /** Is this type different from NoType? */
-    def exists: Boolean = true
+    final def exists: Boolean = !this.eq(NoType)
 
     /** This type, if it exists, otherwise `that` type */
     def orElse(that: => Type) = if (exists) this else that
@@ -223,7 +223,7 @@ object Types {
      *  from the ThisType of `symd`'s owner.
      */
     def isArgPrefixOf(symd: SymDenotation)(implicit ctx: Context) =
-      symd.is(ClassTypeParam) && {
+      symd.isClassTypeParam && {
         this match {
           case tp: ThisType => tp.cls ne symd.owner
           case _ => true
@@ -587,14 +587,14 @@ object Types {
           val jointInfo =
             if (rinfo.isAlias) rinfo
             else if (pdenot.info.isAlias) pdenot.info
-            else if (ctx.pendingMemberSearches.contains(name)) pdenot.info safe_& rinfo
+            else if (ctx.base.pendingMemberSearches.contains(name)) pdenot.info safe_& rinfo
             else pdenot.info recoverable_& rinfo
           pdenot.asSingleDenotation.derivedSingleDenotation(pdenot.symbol, jointInfo)
         } else {
           pdenot & (
             new JointRefDenotation(NoSymbol, rinfo, Period.allInRun(ctx.runId)),
             pre,
-            safeIntersection = ctx.pendingMemberSearches.contains(name))
+            safeIntersection = ctx.base.pendingMemberSearches.contains(name))
         }
       }
 
@@ -639,17 +639,17 @@ object Types {
         case d => d
       }
       def goAnd(l: Type, r: Type) = {
-        go(l) & (go(r), pre, safeIntersection = ctx.pendingMemberSearches.contains(name))
+        go(l) & (go(r), pre, safeIntersection = ctx.base.pendingMemberSearches.contains(name))
       }
 
-      val recCount = ctx.findMemberCount
+      val recCount = ctx.base.findMemberCount
       if (recCount >= Config.LogPendingFindMemberThreshold) {
         if (ctx.property(TypeOps.findMemberLimit).isDefined &&
-            ctx.findMemberCount > Config.PendingFindMemberLimit)
+            ctx.base.findMemberCount > Config.PendingFindMemberLimit)
           return NoDenotation
-        ctx.pendingMemberSearches = name :: ctx.pendingMemberSearches
+        ctx.base.pendingMemberSearches = name :: ctx.base.pendingMemberSearches
       }
-      ctx.findMemberCount = recCount + 1
+      ctx.base.findMemberCount = recCount + 1
       //assert(ctx.findMemberCount < 20)
       try go(this)
       catch {
@@ -659,8 +659,8 @@ object Types {
       }
       finally {
         if (recCount >= Config.LogPendingFindMemberThreshold)
-          ctx.pendingMemberSearches = ctx.pendingMemberSearches.tail
-        ctx.findMemberCount = recCount
+          ctx.base.pendingMemberSearches = ctx.base.pendingMemberSearches.tail
+        ctx.base.findMemberCount = recCount
       }
     }
 
@@ -1904,8 +1904,8 @@ object Types {
      *  not loop before the error is detected.
      */
     final def controlled[T](op: => T)(implicit ctx: Context): T = try {
-      ctx.underlyingRecursions += 1
-      if (ctx.underlyingRecursions < Config.LogPendingUnderlyingThreshold)
+      ctx.base.underlyingRecursions += 1
+      if (ctx.base.underlyingRecursions < Config.LogPendingUnderlyingThreshold)
         op
       else if (ctx.pendingUnderlying contains this)
         throw CyclicReference(symbol)
@@ -1917,7 +1917,7 @@ object Types {
           ctx.pendingUnderlying -= this
         }
     } finally {
-      ctx.underlyingRecursions -= 1
+      ctx.base.underlyingRecursions -= 1
     }
 
     /** The argument corresponding to class type parameter `tparam` as seen from
@@ -1969,7 +1969,7 @@ object Types {
       else if (prefix.isBottomType) prefix
       else if (isType) {
         val res =
-          if (currentSymbol.is(ClassTypeParam)) argForParam(prefix)
+          if (currentSymbol.isClassTypeParam) argForParam(prefix)
           else prefix.lookupRefined(name)
         if (res.exists) res
         else if (Config.splitProjections)
@@ -3711,7 +3711,6 @@ object Types {
 
   /** Sentinel for "missing type" */
   @sharable case object NoType extends CachedGroundType {
-    override def exists = false
     override def computeHash(bs: Binders) = hashSeed
   }
 
@@ -3733,7 +3732,7 @@ object Types {
     def apply(msg: => Message)(implicit ctx: Context): ErrorType = {
       val et = new ErrorType {
         def msg(implicit ctx: Context): Message =
-          ctx.errorTypeMsg.get(this) match {
+          ctx.base.errorTypeMsg.get(this) match {
             case Some(msgFun) => msgFun()
             case None => "error message from previous run no longer available"
           }
@@ -4131,7 +4130,7 @@ object Types {
       else pre match {
         case Range(preLo, preHi) =>
           val forwarded =
-            if (tp.symbol.is(ClassTypeParam)) expandParam(tp, preHi)
+            if (tp.symbol.isClassTypeParam) expandParam(tp, preHi)
             else tryWiden(tp, preHi)
           forwarded.orElse(
             range(super.derivedSelect(tp, preLo), super.derivedSelect(tp, preHi)))
@@ -4561,12 +4560,12 @@ object Types {
   }
 
   // ----- Decorator implicits --------------------------------------------
-
-  implicit def decorateTypeApplications(tpe: Type): TypeApplications = new TypeApplications(tpe)
+  implicit class TypeApplicationsypyp(val self: Type) extends AnyVal with TypeApplications
 
   implicit class typeListDeco(val tps1: List[Type]) extends AnyVal {
     @tailrec def stableHash: Boolean =
       tps1.isEmpty || tps1.head.stableHash && tps1.tail.stableHash
+
     @tailrec def equalElements(tps2: List[Type], bs: BinderPairs): Boolean =
       (tps1 `eq` tps2) || {
         if (tps1.isEmpty) tps2.isEmpty
diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
index 2898db135a3b..afc64118446f 100644
--- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
+++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -107,7 +107,7 @@ class ClassfileParser(
   /** Return the class symbol of the given name. */
   def classNameToSymbol(name: Name)(implicit ctx: Context): Symbol = innerClasses.get(name) match {
     case Some(entry) => innerClasses.classSymbol(entry)
-    case None => ctx.requiredClass(name)
+    case None => ctx.requiredClass(name.toTypeName)
   }
 
   var sawPrivateConstructor = false
@@ -277,7 +277,7 @@ class ClassfileParser(
           if (!enumClass.exists)
             ctx.warning(s"no linked class for java enum $sym in ${sym.owner}. A referencing class file might be missing an InnerClasses entry.")
           else {
-            if (!(enumClass is Flags.Sealed)) enumClass.setFlag(Flags.AbstractSealed)
+            if (!(enumClass is Flags.Sealed)) enumClass.setFlag(Flags.Abstract | Flags.Sealed)
             enumClass.addAnnotation(Annotation.Child(sym))
           }
         }
@@ -556,7 +556,7 @@ class ClassfileParser(
           if (ctx.debug && ctx.verbose)
             println("" + sym + "; signature = " + sig + " type = " + newType)
         case tpnme.SyntheticATTR =>
-          sym.setFlag(Flags.SyntheticArtifact)
+          sym.setFlag(Flags.Synthetic | Flags.Artifact)
         case tpnme.BridgeATTR =>
           sym.setFlag(Flags.Bridge)
         case tpnme.DeprecatedATTR =>
@@ -584,7 +584,7 @@ class ClassfileParser(
           parseExceptions(attrLen)
 
         case tpnme.CodeATTR =>
-          if (sym.owner is Flags.JavaTrait) {
+          if (sym.owner.isJavaTrait) {
             sym.resetFlag(Flags.Deferred)
             sym.owner.resetFlag(Flags.PureInterface)
             ctx.log(s"$sym in ${sym.owner} is a java8+ default method.")
@@ -887,7 +887,7 @@ class ClassfileParser(
         entry.outerName
       } else
         name
-      classNameToSymbol(tlName)
+      classNameToSymbol(tlName.toTypeName)
     }
 
     /** Return the class symbol for `entry`. It looks it up in its outer class.
@@ -912,7 +912,7 @@ class ClassfileParser(
 
       val outerName = entry.outerName.stripModuleClassSuffix
       val innerName = entry.originalName
-      val owner = classNameToSymbol(outerName)
+      val owner = classNameToSymbol(outerName.toTypeName)
       val result = getMember(owner, innerName.toTypeName)(ctx.withPhase(ctx.typerPhase))
       assert(result ne NoSymbol,
         i"""failure to resolve inner class:
@@ -1031,7 +1031,7 @@ class ClassfileParser(
         if (name.endsWith("$") && (name ne nme.nothingRuntimeClass) && (name ne nme.nullRuntimeClass))
           // Null$ and Nothing$ ARE classes
           c = ctx.requiredModule(name.dropRight(1))
-        else c = classNameToSymbol(name)
+        else c = classNameToSymbol(name.toTypeName)
         values(index) = c
       }
       c
@@ -1084,7 +1084,7 @@ class ClassfileParser(
           c = sigToType(name)
           values(index) = c
         } else {
-          val sym = classNameToSymbol(name)
+          val sym = classNameToSymbol(name.toTypeName)
           values(index) = sym
           c = sym.typeRef
         }
diff --git a/compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala b/compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala
index b4a065a473fd..3352e3392cd7 100644
--- a/compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/core/quoted/PickledQuotes.scala
@@ -72,7 +72,7 @@ object PickledQuotes {
    */
   private def encapsulateQuote(tree: Tree)(implicit ctx: Context): Tree = {
     val name = (if (tree.isTerm) "$quote" else "$typeQuote").toTermName
-    val sym = ctx.newSymbol(ctx.owner, name, Synthetic, defn.AnyType, coord = tree.pos)
+    val sym = ctx.newSymbol(ctx.owner, name, Synthetic, defn.AnyType, coord = tree.coord)
     val encoded =
       if (tree.isTerm) tree
       else Literal(Constant(null)).select(nme.asInstanceOf_).appliedToTypeTrees(tree :: Nil)
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
index 1d0ab3ac40e9..7d6cf3698f7a 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
@@ -48,7 +48,7 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
       def printNat() = print(Yellow(" " + readNat()).show)
       def printName() = {
         val idx = readNat()
-        print(nameColor(" " + idx + " [" + nameRefToString(NameRef(idx)) + "]").show)
+        print(nameColor(" " + idx + " [" + nameRefToString(NameRef(idx)) + "]"))
       }
       def printTree(): Unit = {
         newLine()
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index f9652f19a4d8..dffebfc35896 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -22,7 +22,7 @@ object TreePickler {
 
   case class Hole(idx: Int, args: List[tpd.Tree]) extends tpd.TermTree {
     override def fallbackToText(printer: Printer): Text =
-      s"[[$idx|" ~~ printer.toTextGlobal(args, ", ") ~~ "]]"
+      s"[[$idx|".toText ~~ printer.toTextGlobal(args, ", ") ~~ "]]"
   }
 }
 
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 7f64f2cfb941..7e5a74ea1e3d 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -1164,7 +1164,7 @@ class TreeUnpickler(reader: TastyReader,
     def coordAt(addr: Addr)(implicit ctx: Context): Coord = {
       val pos = posAt(addr)
       if (pos.exists)
-        positionCoord(pos)
+        pos.toCoord
       else
         indexCoord(addr.index)
     }
diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
index d1019095edeb..e9aee1d6f2e9 100644
--- a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -115,7 +115,7 @@ object Scala2Unpickler {
       if (tsym.exists) tsym.setFlag(TypeParam)
       else denot.enter(tparam, decls)
     }
-    if (!(denot.flagsUNSAFE is JavaModule)) ensureConstructor(denot.symbol.asClass, decls)
+    if (!denot.flagsUNSAFE.isBoth(JavaDefined, and = Module)) ensureConstructor(denot.symbol.asClass, decls)
 
     val scalacCompanion = denot.classSymbol.scalacLinkedClass
 
@@ -435,7 +435,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     val owner = readSymbolRef()
 
     var flags = unpickleScalaFlags(readLongNat(), name.isTypeName)
-    if (flags is DefaultParameter) {
+    if (flags.isBoth(Param, and = DefaultParameterized)) {
       // DefaultParameterized flag now on method, not parameter
       //assert(flags is Param, s"$name0 in $owner")
       flags = flags &~ DefaultParameterized
@@ -575,9 +575,9 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
 
             if (denot.isConstructor) addConstructorTypeParams(denot)
             if (atEnd) {
-              assert(!denot.isSuperAccessor, denot)
+              assert(!denot.symbol.isSuperAccessor, denot)
             } else {
-              assert(denot.is(ParamAccessor) || denot.isSuperAccessor, denot)
+              assert(denot.is(ParamAccessor) || denot.symbol.isSuperAccessor, denot)
               def disambiguate(alt: Symbol) = { // !!! DEBUG
                 trace.onDebug(s"disambiguating ${denot.info} =:= ${denot.owner.thisType.memberInfo(alt)} ${denot.owner}") {
                   denot.info matches denot.owner.thisType.memberInfo(alt)
diff --git a/compiler/src/dotty/tools/dotc/fromtasty/ReadTastyTreesFromClasses.scala b/compiler/src/dotty/tools/dotc/fromtasty/ReadTastyTreesFromClasses.scala
index 7b3b9635192e..45c49994d70e 100644
--- a/compiler/src/dotty/tools/dotc/fromtasty/ReadTastyTreesFromClasses.scala
+++ b/compiler/src/dotty/tools/dotc/fromtasty/ReadTastyTreesFromClasses.scala
@@ -61,7 +61,7 @@ class ReadTastyTreesFromClasses extends FrontEnd {
       // Note that if both the class and the object are present, then loading the class will also load
       // the object, this is why we use orElse here, otherwise we could load the object twice and
       // create ambiguities!
-      ctx.staticRef(className) match {
+      ctx.base.staticRef(className) match {
         case clsd: ClassDenotation =>
           clsd.infoOrCompleter match {
             case info: ClassfileLoader =>
diff --git a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
index d6401bba8371..5cca38005fab 100644
--- a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
@@ -125,7 +125,7 @@ object JavaParsers {
       // can call it.
       if (needsDummyConstr) {
         stats1 = constr1 :: stats1
-        constr1 = makeConstructor(List(scalaDot(tpnme.Unit)), tparams, Flags.JavaDefined | Flags.PrivateLocal)
+        constr1 = makeConstructor(List(scalaDot(tpnme.Unit)), tparams, Flags.JavaDefined | Flags.Private | Flags.Local)
       }
       Template(constr1.asInstanceOf[DefDef], parents, EmptyValDef, stats1)
     }
@@ -406,7 +406,7 @@ object JavaParsers {
       throw new RuntimeException
     }
 
-    def typeParams(flags: FlagSet = Flags.JavaDefined | Flags.PrivateLocal | Flags.Param): List[TypeDef] =
+    def typeParams(flags: FlagSet = Flags.JavaDefined | Flags.Private | Flags.Local | Flags.Param): List[TypeDef] =
       if (in.token == LT) {
         in.nextToken()
         val tparams = repsep(() => typeParam(flags), COMMA)
@@ -716,7 +716,7 @@ object JavaParsers {
       val iface = atPos(start, nameOffset) {
         TypeDef(
           name,
-          makeTemplate(parents, body, tparams, false)).withMods(mods | Flags.Trait | Flags.JavaInterface | Flags.Abstract)
+          makeTemplate(parents, body, tparams, false)).withMods(mods | Flags.Trait | Flags.JavaDefined | Flags.Abstract)
       }
       addCompanionObject(statics, iface)
     }
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 7e4d94dc1f93..f6bbb657df09 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -235,8 +235,8 @@ object Parsers {
       }
     }
 
-    def warning(msg: => Message, sourcePos: SourcePosition) =
-      ctx.warning(msg, sourcePos)
+    def warning(msg: => Message, pos: SourcePosition) =
+      ctx.warning(msg, pos)
 
     def warning(msg: => Message, offset: Int = in.offset) =
       ctx.warning(msg, source atPos Position(offset))
@@ -1301,7 +1301,7 @@ object Parsers {
         case USCORE =>
           val start = in.skipToken()
           val pname = WildcardParamName.fresh()
-          val param = ValDef(pname, TypeTree(), EmptyTree).withFlags(SyntheticTermParam)
+          val param = ValDef(pname, TypeTree(), EmptyTree).withFlags(Synthetic | TermParam)
             .withPos(Position(start))
           placeholderParams = param :: placeholderParams
           atPos(start) { Ident(pname) }
@@ -1657,7 +1657,7 @@ object Parsers {
     private def normalize(mods: Modifiers): Modifiers =
       if ((mods is Private) && mods.hasPrivateWithin)
         normalize(mods &~ Private)
-      else if (mods is AbstractAndOverride)
+      else if (mods.isBoth(Abstract, and = Override))
         normalize(addFlag(mods &~ (Abstract | Override), AbsOverride))
       else
         mods
@@ -1791,7 +1791,7 @@ object Parsers {
         val start = in.offset
         val mods = atPos(start) {
           annotsAsMods() | {
-            if (ownerKind == ParamOwner.Class) Param | PrivateLocal
+            if (ownerKind == ParamOwner.Class) Param | Private | Local
             else Param
           } | {
             if (ownerKind != ParamOwner.Def)
@@ -1851,7 +1851,7 @@ object Parsers {
               } else {
                 if (!(mods.flags &~ (ParamAccessor | Inline)).isEmpty)
                   syntaxError("`val' or `var' expected")
-                if (firstClauseOfCaseClass) mods else mods | PrivateLocal
+                if (firstClauseOfCaseClass) mods else mods | Private | Local
               }
             }
         }
diff --git a/compiler/src/dotty/tools/dotc/parsing/SymbolicXMLBuilder.scala b/compiler/src/dotty/tools/dotc/parsing/SymbolicXMLBuilder.scala
index ceef07d4ca36..a762cbfcaedd 100644
--- a/compiler/src/dotty/tools/dotc/parsing/SymbolicXMLBuilder.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/SymbolicXMLBuilder.scala
@@ -34,29 +34,29 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(implicit ctx: Cont
   private[parsing] var isPattern: Boolean = _
 
   private object xmltypes extends ScalaTypeNames {
-    val _Comment: TypeName             = "Comment"
-    val _Elem: TypeName                = "Elem"
-    val _EntityRef: TypeName           = "EntityRef"
-    val _Group: TypeName               = "Group"
-    val _MetaData: TypeName            = "MetaData"
-    val _NamespaceBinding: TypeName    = "NamespaceBinding"
-    val _NodeBuffer: TypeName          = "NodeBuffer"
-    val _PrefixedAttribute: TypeName   = "PrefixedAttribute"
-    val _ProcInstr: TypeName           = "ProcInstr"
-    val _Text: TypeName                = "Text"
-    val _Unparsed: TypeName            = "Unparsed"
-    val _UnprefixedAttribute: TypeName = "UnprefixedAttribute"
+    val _Comment: TypeName             = n("Comment")
+    val _Elem: TypeName                = n("Elem")
+    val _EntityRef: TypeName           = n("EntityRef")
+    val _Group: TypeName               = n("Group")
+    val _MetaData: TypeName            = n("MetaData")
+    val _NamespaceBinding: TypeName    = n("NamespaceBinding")
+    val _NodeBuffer: TypeName          = n("NodeBuffer")
+    val _PrefixedAttribute: TypeName   = n("PrefixedAttribute")
+    val _ProcInstr: TypeName           = n("ProcInstr")
+    val _Text: TypeName                = n("Text")
+    val _Unparsed: TypeName            = n("Unparsed")
+    val _UnprefixedAttribute: TypeName = n("UnprefixedAttribute")
   }
 
   private object xmlterms extends ScalaTermNames {
-    val _Null: TermName     = "Null"
-    val __Elem: TermName    = "Elem"
-    val __Text: TermName    = "Text"
-    val _buf: TermName      = "$buf"
-    val _md: TermName       = "$md"
-    val _plus: TermName     = "&+"
-    val _tmpscope: TermName = "$tmpscope"
-    val _xml: TermName      = "xml"
+    val _Null: TermName     = n("Null")
+    val __Elem: TermName    = n("Elem")
+    val __Text: TermName    = n("Text")
+    val _buf: TermName      = n("$buf")
+    val _md: TermName       = n("$md")
+    val _plus: TermName     = n("&+")
+    val _tmpscope: TermName = n("$tmpscope")
+    val _xml: TermName      = n("xml")
   }
 
   import xmltypes.{_Comment, _Elem, _EntityRef, _Group, _MetaData, _NamespaceBinding, _NodeBuffer,
diff --git a/compiler/src/dotty/tools/dotc/printing/DecompilerPrinter.scala b/compiler/src/dotty/tools/dotc/printing/DecompilerPrinter.scala
index 392d719cfefd..a1dba713e618 100644
--- a/compiler/src/dotty/tools/dotc/printing/DecompilerPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/DecompilerPrinter.scala
@@ -35,16 +35,15 @@ class DecompilerPrinter(_ctx: Context) extends RefinedPrinter(_ctx) {
 
   override protected def templateText(tree: TypeDef, impl: Template): Text = {
     val decl =
-      if (!tree.mods.is(Module)) modText(tree.mods, keywordStr(if ((tree).mods is Trait) "trait" else "class"))
-      else modText(tree.mods &~ (Final | Module), keywordStr("object"))
+      if (!modifiers(tree).is(Module)) modText(modifiers(tree), keywordStr(if (modifiers(tree) is Trait) "trait" else "class"))
+      else modText(modifiers(tree) &~ (Final | Module), keywordStr("object"))
     decl ~~ typeText(nameIdText(tree)) ~ withEnclosingDef(tree) { toTextTemplate(impl) } ~ ""
   }
 
   override protected def defDefToText[T >: Untyped](tree: DefDef[T]): Text = {
-    import untpd.{modsDeco => _, _}
     dclTextOr(tree) {
       val printLambda = tree.symbol.isAnonymousFunction
-      val prefix = modText(tree.mods, keywordStr("def")) ~~ valDefText(nameIdText(tree)) provided (!printLambda)
+      val prefix = modText(modifiers(tree), keywordStr("def")) ~~ valDefText(nameIdText(tree)) provided (!printLambda)
       withEnclosingDef(tree) {
         addVparamssText(prefix ~ tparamsText(tree.tparams), tree.vparamss) ~ optAscription(tree.tpt).provided(!printLambda) ~
           optText(tree.rhs)((if (printLambda) " => " else " = ") ~ _)
diff --git a/compiler/src/dotty/tools/dotc/printing/Formatting.scala b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
index d33e0af00ddb..3a04d0e75bd1 100644
--- a/compiler/src/dotty/tools/dotc/printing/Formatting.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
@@ -138,7 +138,7 @@ object Formatting {
       seen.record(super.ParamRefNameString(param), param)
 
     override def toTextRef(tp: SingletonType): Text = tp match {
-      case tp: SkolemType => seen.record(tp.repr.toString, tp)
+      case tp: SkolemType => seen.record(tp.repr.toString, tp).toText
       case _ => super.toTextRef(tp)
     }
   }
diff --git a/compiler/src/dotty/tools/dotc/printing/Highlighting.scala b/compiler/src/dotty/tools/dotc/printing/Highlighting.scala
index 3bda7fb7ae64..cdc1d966be4b 100644
--- a/compiler/src/dotty/tools/dotc/printing/Highlighting.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Highlighting.scala
@@ -7,9 +7,6 @@ import core.Contexts.Context
 
 object Highlighting {
 
-  implicit def highlightShow(h: Highlight)(implicit ctx: Context): String =
-    h.show
-
   abstract class Highlight(private val highlight: String) {
     def text: String
 
diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index f5f503207e05..698b6fb8695b 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -22,17 +22,17 @@ class PlainPrinter(_ctx: Context) extends Printer {
   protected def maxToTextRecursions = 100
 
   protected final def controlled(op: => Text): Text =
-    if (ctx.toTextRecursions < maxToTextRecursions && ctx.toTextRecursions < maxSummarized)
+    if (ctx.base.toTextRecursions < maxToTextRecursions && ctx.base.toTextRecursions < maxSummarized)
       try {
-        ctx.toTextRecursions += 1
+        ctx.base.toTextRecursions += 1
         op
       } finally {
-        ctx.toTextRecursions -= 1
+        ctx.base.toTextRecursions -= 1
       }
     else {
-      if (ctx.toTextRecursions >= maxToTextRecursions)
+      if (ctx.base.toTextRecursions >= maxToTextRecursions)
         recursionLimitExceeded()
-      "..."
+      "...".toText
     }
 
   protected def recursionLimitExceeded() = {
@@ -47,7 +47,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     if (homogenizedView)
       tp match {
         case tp: ThisType if tp.cls.is(Package) && !tp.cls.isEffectiveRoot =>
-          ctx.requiredPackage(tp.cls.fullName).termRef
+          ctx.requiredPackage(tp.cls.fullName.toTermName).termRef
         case tp: TypeVar if tp.isInstantiated =>
           homogenize(tp.instanceOpt)
         case AndType(tp1, tp2) =>
@@ -138,7 +138,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
         else
           toTextPrefix(tp.prefix) ~ selectionString(tp)
       case tp: TermParamRef =>
-        ParamRefNameString(tp) ~ ".type"
+        ParamRefNameString(tp) ~ ".type".toText
       case tp: TypeParamRef =>
         ParamRefNameString(tp) ~ lambdaHash(tp.binder)
       case tp: SingletonType =>
@@ -152,7 +152,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case tp: RecType =>
         try {
           openRecs = tp :: openRecs
-          "{" ~ selfRecName(openRecs.length) ~ " => " ~ toTextGlobal(tp.parent) ~ "}"
+          "{" ~ selfRecName(openRecs.length).toText ~ " => " ~ toTextGlobal(tp.parent) ~ "}"
         }
         finally openRecs = openRecs.tail
       case AndType(tp1, tp2) =>
@@ -160,13 +160,13 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case OrType(tp1, tp2) =>
         changePrec(OrPrec) { toText(tp1) ~ " | " ~ toText(tp2) }
       case tp: ErrorType =>
-        s"<error ${tp.msg.msg}>"
+        s"<error ${tp.msg.msg}>".toText
       case tp: WildcardType =>
-        if (tp.optBounds.exists) "(?" ~ toTextRHS(tp.bounds) ~ ")" else "?"
+        if (tp.optBounds.exists) "(?" ~ toTextRHS(tp.bounds) ~ ")" else "?".toText
       case NoType =>
-        "<notype>"
+        "<notype>".toText
       case NoPrefix =>
-        "<noprefix>"
+        "<noprefix>".toText
       case tp: MethodType =>
         changePrec(GlobalPrec) {
           (if (tp.isImplicitMethod) "(implicit " else "(") ~ paramsText(tp) ~
@@ -222,10 +222,10 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   /** If -uniqid is set, the hashcode of the lambda type, after a # */
   protected def lambdaHash(pt: LambdaType): Text =
-    if (ctx.settings.uniqid.value)
+    (if (ctx.settings.uniqid.value)
       try "#" + pt.hashCode
       catch { case ex: NullPointerException => "" }
-    else ""
+    else "").toText
 
   /** If -uniqid is set, the unique id of symbol, after a # */
   protected def idString(sym: Symbol): String =
@@ -259,7 +259,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case tp: TermRef =>
         toTextPrefix(tp.prefix) ~ selectionString(tp)
       case tp: ThisType =>
-        nameString(tp.cls) + ".this"
+        (nameString(tp.cls) + ".this").toText
       case SuperType(thistpe: SingletonType, _) =>
         toTextRef(thistpe).map(_.replaceAll("""\bthis$""", "super"))
       case SuperType(thistpe, _) =>
@@ -267,11 +267,11 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case tp @ ConstantType(value) =>
         toText(value)
       case pref: TermParamRef =>
-        nameString(pref.binder.paramNames(pref.paramNum))
+        nameString(pref.binder.paramNames(pref.paramNum)).toText
       case tp: RecThis =>
         val idx = openRecs.reverse.indexOf(tp.binder)
-        if (idx >= 0) selfRecName(idx + 1)
-        else "{...}.this" // TODO move underlying type to an addendum, e.g. ... z3 ... where z3: ...
+        (if (idx >= 0) selfRecName(idx + 1)
+        else "{...}.this").toText // TODO move underlying type to an addendum, e.g. ... z3 ... where z3: ...
       case tp: SkolemType =>
         if (homogenizedView) toText(tp.info) else toText(tp.repr)
     }
@@ -280,7 +280,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
   /** The string representation of this type used as a prefix */
   protected def toTextPrefix(tp: Type): Text = controlled {
     homogenize(tp) match {
-      case NoPrefix => ""
+      case NoPrefix => "".toText
       case tp: SingletonType => toTextRef(tp) ~ "."
       case tp => trimPrefix(toTextLocal(tp)) ~ "#"
     }
@@ -297,7 +297,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
    */
   protected def toTextRHS(optType: Option[Type]): Text = optType match {
     case Some(tp) => toTextRHS(tp)
-    case None => "?"
+    case None => "?".toText
   }
 
   /** String representation of a definition's type following its name */
@@ -315,7 +315,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
           if (tparams.isEmpty) Text() else ("[" ~ dclsText(tparams) ~ "]").close
         val selfText: Text = selfInfo match {
           case NoType => Text()
-          case sym: Symbol if !sym.isCompleted => "this: ? =>"
+          case sym: Symbol if !sym.isCompleted => "this: ? =>".toText
           case _ => "this: " ~ atPrec(InfixPrec) { toText(tp.selfType) } ~ " =>"
         }
         val trueDecls = otherDecls.filterNot(treatAsTypeArg)
@@ -365,7 +365,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
   /** String representation of symbol's definition key word */
   protected def keyString(sym: Symbol): String = {
     val flags = sym.flagsUNSAFE
-    if (flags is JavaTrait) "interface"
+    if (flags.isBoth(JavaDefined, and = Trait)) "interface"
     else if (flags is Trait) "trait"
     else if (sym.isClass) "class"
     else if (sym.isType) "type"
@@ -373,13 +373,13 @@ class PlainPrinter(_ctx: Context) extends Printer {
     else if (flags is Package) "package"
     else if (flags is Module) "object"
     else if (sym is Method) "def"
-    else if (sym.isTerm && (!(flags is Param))) "val"
+    else if (sym.isTerm && !flags.is(Param)) "val"
     else ""
   }
 
   /** String representation of symbol's flags */
   protected def toTextFlags(sym: Symbol): Text =
-    Text(sym.flagsUNSAFE.flagStrings map stringToText, " ")
+    Text(sym.flagsUNSAFE.flagStrings.map(_.toText), " ")
 
   /** String representation of symbol's variance or "" if not applicable */
   protected def varianceString(sym: Symbol): String = varianceString(sym.variance)
@@ -398,17 +398,17 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   private def dclTextWithInfo(sym: Symbol, info: Option[Type]): Text =
     (toTextFlags(sym) ~~ keyString(sym) ~~
-      (varianceString(sym) ~ nameString(sym)) ~ toTextRHS(info)).close
+      (varianceString(sym) ~ nameString(sym).toText) ~ toTextRHS(info)).close
 
   def toText(sym: Symbol): Text =
-    (kindString(sym) ~~ {
+    (kindString(sym).toText ~~ {
       if (sym.isAnonymousClass) toText(sym.info.parents, " with ") ~ "{...}"
-      else if (hasMeaninglessName(sym)) simpleNameString(sym.owner) + idString(sym)
-      else nameString(sym)
+      else if (hasMeaninglessName(sym)) (simpleNameString(sym.owner) + idString(sym)).toText
+      else nameString(sym).toText
     }).close
 
   def locationText(sym: Symbol): Text =
-    if (!sym.exists) ""
+    if (!sym.exists) "".toText
     else {
       val ownr = sym.effectiveOwner
       if (ownr.isClass && !isEmptyPrefix(ownr)) " in " ~ toText(ownr) else Text()
@@ -418,7 +418,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     (toText(sym) ~ locationText(sym)).close
 
   def extendedLocationText(sym: Symbol): Text =
-    if (!sym.exists) ""
+    if (!sym.exists) "".toText
     else {
       def recur(ownr: Symbol, innerLocation: String): Text = {
         def nextOuter(innerKind: String): Text =
@@ -426,10 +426,10 @@ class PlainPrinter(_ctx: Context) extends Printer {
             if (!innerLocation.isEmpty) innerLocation
             else s" in an anonymous $innerKind")
         def showLocation(ownr: Symbol, where: String): Text =
-          innerLocation ~ " " ~ where ~ " " ~ toText(ownr)
+          innerLocation ~ " ".toText ~ where ~ " " ~ toText(ownr)
         if (ownr.isAnonymousClass) nextOuter("class")
         else if (ownr.isAnonymousFunction) nextOuter("function")
-        else if (isEmptyPrefix(ownr)) ""
+        else if (isEmptyPrefix(ownr)) "".toText
         else if (ownr.isLocalDummy) showLocation(ownr.owner, "locally defined in")
         else if (ownr.isTerm && !ownr.is(Module | Method)) showLocation(ownr, "in the initalizer of")
         else showLocation(ownr, "in")
@@ -461,7 +461,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
     case _ => literalText(String.valueOf(const.value))
   }
 
-  def toText(annot: Annotation): Text = s"@${annot.symbol.name}" // for now
+  def toText(annot: Annotation): Text = s"@${annot.symbol.name}".toText // for now
 
   protected def escapedString(str: String): String = str flatMap escapedChar
 
@@ -476,9 +476,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
         def toTextElem(elem: Any): Text = elem match {
           case elem: Showable => elem.toText(this)
           case elem: List[_] => "List(" ~ Text(elem map toTextElem, ",") ~ ")"
-          case elem => elem.toString
+          case elem => elem.toString.toText
         }
-        val nodeName = node.productPrefix
+        val nodeName = node.productPrefix.toText
         val elems =
           Text(node.productIterator.map(toTextElem).toList, ", ")
         val tpSuffix =
@@ -498,13 +498,13 @@ class PlainPrinter(_ctx: Context) extends Printer {
       "SearchSuccess: " ~ toText(result.ref) ~ " via " ~ toText(result.tree)
     case result: SearchFailure =>
       result.reason match {
-        case _: NoMatchingImplicits => "No Matching Implicit"
-        case _: DivergingImplicit => "Diverging Implicit"
-        case _: ShadowedImplicit => "Shadowed Implicit"
+        case _: NoMatchingImplicits => "No Matching Implicit".toText
+        case _: DivergingImplicit => "Diverging Implicit".toText
+        case _: ShadowedImplicit => "Shadowed Implicit".toText
         case result: AmbiguousImplicits =>
           "Ambiguous Implicit: " ~ toText(result.alt1.ref) ~ " and " ~ toText(result.alt2.ref)
         case _ =>
-          "?Unknown Implicit Result?" + result.getClass
+          s"?Unknown Implicit Result?${result.getClass}".toText
     }
   }
 
@@ -515,7 +515,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
       case Ident(name) :: Nil => name.show
       case _ => "{...}"
     }
-    s"import $exprStr.$selectorStr"
+    s"import $exprStr.$selectorStr".toText
   }
 
 
@@ -523,7 +523,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   def summarized[T](depth: Int)(op: => T): T = {
     val saved = maxSummarized
-    maxSummarized = ctx.toTextRecursions + depth
+    maxSummarized = ctx.base.toTextRecursions + depth
     try op
     finally maxSummarized = depth
   }
@@ -533,15 +533,16 @@ class PlainPrinter(_ctx: Context) extends Printer {
   def plain = this
 
   protected def keywordStr(text: String): String = coloredStr(text, SyntaxHighlighting.KeywordColor)
-  protected def keywordText(text: String): Text = coloredStr(text, SyntaxHighlighting.KeywordColor)
+  protected def keywordText(text: String): Text = keywordStr(text).toText
   protected def valDefText(text: Text): Text = coloredText(text, SyntaxHighlighting.ValDefColor)
   protected def typeText(text: Text): Text = coloredText(text, SyntaxHighlighting.TypeColor)
   protected def literalText(text: Text): Text = coloredText(text, SyntaxHighlighting.LiteralColor)
+  protected def literalText(string: String): Text = literalText(string.toText)
   protected def stringText(text: Text): Text = coloredText(text, SyntaxHighlighting.StringColor)
+  protected def stringText(string: String): Text = stringText(string.toText)
 
   private def coloredStr(text: String, color: String): String =
     if (ctx.useColors) color + text + SyntaxHighlighting.NoColor else text
   private def coloredText(text: Text, color: String): Text =
     if (ctx.useColors) color ~ text ~ SyntaxHighlighting.NoColor else text
 }
-
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index 48bc992f8a47..edbabd9dcf85 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -95,8 +95,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   override def toTextRef(tp: SingletonType): Text = controlled {
     tp match {
       case tp: ThisType =>
-        if (tp.cls.isAnonymousClass) return keywordStr("this")
-        if (tp.cls is ModuleClass) return fullNameString(tp.cls.sourceModule)
+        if (tp.cls.isAnonymousClass) return keywordText("this")
+        if (tp.cls is ModuleClass) return fullNameString(tp.cls.sourceModule).toText
       case _ =>
     }
     super.toTextRef(tp)
@@ -109,11 +109,11 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       else isOmittablePrefix(sym)
     tp match {
       case tp: ThisType =>
-        if (isOmittable(tp.cls)) return ""
+        if (isOmittable(tp.cls)) return "".toText
       case tp @ TermRef(pre, _) =>
         val sym = tp.symbol
         if (sym.isPackageObject) return toTextPrefix(pre)
-        if (isOmittable(sym)) return ""
+        if (isOmittable(sym)) return "".toText
       case _ =>
     }
     super.toTextPrefix(tp)
@@ -187,7 +187,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         if (tp.symbol.is(Param))
           tp.prefix match {
             case pre: ThisType if pre.cls == tp.symbol.owner =>
-              return nameString(tp.symbol)
+              return nameString(tp.symbol).toText
             case _ =>
           }
       case tp: ExprType =>
@@ -217,7 +217,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         }
         return "FunProto(" ~ argsText ~ "):" ~ toText(resultType)
       case tp: IgnoredProto =>
-        return "?"
+        return "?".toText
       case _ =>
     }
     super.toText(tp)
@@ -230,7 +230,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     ("{" ~ toText(trees, "\n") ~ "}").close
 
   override def toText[T >: Untyped](tree: Tree[T]): Text = controlled {
-    import untpd.{modsDeco => _, _}
+    import untpd._
 
     def isLocalThis(tree: Tree) = tree.typeOpt match {
       case tp: ThisType => tp.cls == ctx.owner.enclosingClass
@@ -288,7 +288,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         val txt = tree.typeOpt match {
           case tp: NamedType if name != nme.WILDCARD =>
             val pre = if (tp.symbol is JavaStatic) tp.prefix.widen else tp.prefix
-            toTextPrefix(pre) ~ withPos(selectionString(tp), tree.pos)
+            toTextPrefix(pre) ~ withPos(selectionString(tp).toText, tree.pos)
           case _ =>
             toText(name)
         }
@@ -403,7 +403,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case tree @ TypeDef(name, rhs) =>
         def typeDefText(tparamsText: => Text, rhsText: => Text) =
           dclTextOr(tree) {
-            modText(tree.mods, keywordStr("type")) ~~ (varianceText(tree.mods) ~ typeText(nameIdText(tree))) ~
+            modText(modifiers(tree), keywordStr("type")) ~~ (varianceText(modifiers(tree)) ~ typeText(nameIdText(tree))) ~
             withEnclosingDef(tree) { tparamsText ~ rhsText }
           }
         def recur(rhs: Tree, tparamsTxt: => Text): Text = rhs match {
@@ -418,7 +418,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case rhs =>
             typeDefText(tparamsTxt, optText(rhs)(" = " ~ _))
         }
-        recur(rhs, "")
+        recur(rhs, "".toText)
       case Import(expr, selectors) =>
         def selectorText(sel: Tree): Text = sel match {
           case Thicket(l :: r :: Nil) => toTextGlobal(l) ~ " => " ~ toTextGlobal(r)
@@ -436,17 +436,17 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case Annotated(arg, annot) =>
         toTextLocal(arg) ~~ annotText(annot)
       case EmptyTree =>
-        "<empty>"
+        "<empty>".toText
       case TypedSplice(t) =>
         toText(t)
       case tree @ ModuleDef(name, impl) =>
         withEnclosingDef(tree) {
-          modText(tree.mods, keywordStr("object")) ~~ nameIdText(tree) ~ toTextTemplate(impl)
+          modText(modifiers(tree), keywordStr("object")) ~~ nameIdText(tree) ~ toTextTemplate(impl)
         }
       case SymbolLit(str) =>
-        "'" + str
+        ("'" + str).toText
       case InterpolatedString(id, segments) =>
-        def strText(str: Literal) = withPos(escapedString(str.const.stringValue), tree.pos)
+        def strText(str: Literal) = withPos(escapedString(str.const.stringValue).toText, tree.pos)
         def segmentText(segment: Tree) = segment match {
           case Thicket(List(str: Literal, expr)) => strText(str) ~ "{" ~ toTextGlobal(expr) ~ "}"
           case str: Literal => strText(str)
@@ -457,7 +457,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         def argToText(arg: Tree) = arg match {
           case arg @ ValDef(name, tpt, _) =>
             val implicitText =
-              if ((arg.mods is Implicit) && !implicitSeen) { implicitSeen = true; keywordStr("implicit ") }
+              if ((modifiers(arg) is Implicit) && !implicitSeen) { implicitSeen = true; keywordStr("implicit ") }
               else ""
             implicitText ~ toText(name) ~ optAscription(tpt)
           case _ =>
@@ -507,7 +507,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case Quote(tree) =>
         if (tree.isType) "'[" ~ toTextGlobal(tree) ~ "]" else "'(" ~ toTextGlobal(tree) ~ ")"
       case Thicket(trees) =>
-        "Thicket {" ~~ toTextGlobal(trees, "\n") ~~ "}"
+        "Thicket {".toText ~~ toTextGlobal(trees, "\n") ~~ "}"
       case _ =>
         tree.fallbackToText(this)
     }
@@ -560,28 +560,31 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   }
 
   /** Print modifiers from symbols if tree has type, overriding the untpd behavior. */
-  implicit def modsDeco(mdef: untpd.MemberDef)(implicit ctx: Context): untpd.ModsDecorator =
-    new untpd.ModsDecorator {
-      def mods = if (mdef.hasType) Modifiers(mdef.symbol) else mdef.rawMods
+  def modifiers(mdef: untpd.MemberDef)(implicit ctx: Context): Modifiers = {
+    if (mdef.hasType) {
+      val sym = mdef.symbol
+      untpd.Modifiers(
+        sym.flags & (if (sym.isType) ModifierFlags | VarianceFlags else ModifierFlags),
+        if (sym.privateWithin.exists) sym.privateWithin.asType.name else tpnme.EMPTY,
+        sym.annotations map (_.tree)
+      )
     }
-
-  def Modifiers(sym: Symbol)(implicit ctx: Context): Modifiers = untpd.Modifiers(
-    sym.flags & (if (sym.isType) ModifierFlags | VarianceFlags else ModifierFlags),
-    if (sym.privateWithin.exists) sym.privateWithin.asType.name else tpnme.EMPTY,
-    sym.annotations map (_.tree))
+    else
+      mdef.mods
+  }
 
   protected def optAscription[T >: Untyped](tpt: Tree[T]) = optText(tpt)(": " ~ _)
 
   private def idText(tree: untpd.Tree): Text = {
     if ((ctx.settings.uniqid.value || Printer.debugPrintUnique) && tree.hasType && tree.symbol.exists) s"#${tree.symbol.id}" else ""
-  }
+  }.toText
 
   private def useSymbol(tree: untpd.Tree) =
     tree.hasType && tree.symbol.exists && ctx.settings.YprintSyms.value
 
   protected def nameIdText[T >: Untyped](tree: NameTree[T]): Text = {
     if (tree.hasType && tree.symbol.exists) {
-      val str: Text = nameString(tree.symbol)
+      val str: Text = nameString(tree.symbol).toText
       tree match {
         case tree: RefTree => withPos(str, tree.pos)
         case tree: MemberDef => withPos(str, tree.namePos)
@@ -604,18 +607,16 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     (txt /: vparamss)((txt, vparams) => txt ~ "(" ~ toText(vparams, ", ") ~ ")")
 
   protected def valDefToText[T >: Untyped](tree: ValDef[T]): Text = {
-    import untpd.{modsDeco => _, _}
     dclTextOr(tree) {
-      modText(tree.mods, keywordStr(if (tree.mods is Mutable) "var" else "val")) ~~
+      modText(modifiers(tree), keywordStr(if (modifiers(tree) is Mutable) "var" else "val")) ~~
         valDefText(nameIdText(tree)) ~ optAscription(tree.tpt) ~
         withEnclosingDef(tree) { optText(tree.rhs)(" = " ~ _) }
     }
   }
 
   protected def defDefToText[T >: Untyped](tree: DefDef[T]): Text = {
-    import untpd.{modsDeco => _, _}
     dclTextOr(tree) {
-      val prefix = modText(tree.mods, keywordStr("def")) ~~ valDefText(nameIdText(tree))
+      val prefix = modText(modifiers(tree), keywordStr("def")) ~~ valDefText(nameIdText(tree))
       withEnclosingDef(tree) {
           addVparamssText(prefix ~ tparamsText(tree.tparams), tree.vparamss) ~ optAscription(tree.tpt) ~
             optText(tree.rhs)(" = " ~ _)
@@ -630,9 +631,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     val prefix: Text =
       if (vparamss.isEmpty || primaryConstrs.nonEmpty) tparamsTxt
       else {
-        var modsText = modText(constr.mods, "")
+        var modsText = modText(modifiers(constr), "")
         if (!modsText.isEmpty) modsText = " " ~ modsText
-        if (constr.mods.hasAnnotations && !constr.mods.hasFlags) modsText = modsText ~~ " this"
+        if (modifiers(constr).hasAnnotations && !modifiers(constr).hasFlags) modsText = modsText ~~ " this"
         withEnclosingDef(constr) { addVparamssText(tparamsTxt ~~ modsText, vparamss) }
       }
     val parentsText = Text(parents map constrText, keywordStr(" with "))
@@ -652,13 +653,13 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       params ::: rest
     } else impl.body
 
-    val bodyText = "{" ~~ selfText ~~ toTextGlobal(primaryConstrs ::: body, "\n") ~ "}"
+    val bodyText = "{".toText ~~ selfText ~~ toTextGlobal(primaryConstrs ::: body, "\n") ~ "}"
 
     prefix ~ (keywordText(" extends") provided !ofNew) ~~ parentsText ~~ bodyText
   }
 
   protected def templateText(tree: TypeDef, impl: Template): Text = {
-    val decl = modText(tree.mods, keywordStr(if ((tree).mods is Trait) "trait" else "class"))
+    val decl = modText(modifiers(tree), keywordStr(if (modifiers(tree) is Trait) "trait" else "class"))
     decl ~~ typeText(nameIdText(tree)) ~ withEnclosingDef(tree) { toTextTemplate(impl) } ~
       (if (tree.hasType && ctx.settings.verbose.value) i"[decls = ${tree.symbol.info.decls}]" else "")
   }
@@ -682,7 +683,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   protected def annotText(tree: untpd.Tree): Text = "@" ~ constrText(tree) // DD
 
   protected def modText(mods: untpd.Modifiers, kw: String): Text = { // DD
-    val suppressKw = if (enclDefIsClass) mods is ParamAndLocal else mods is Param
+    val suppressKw = if (enclDefIsClass) mods isBoth(Param, and = Local) else mods is Param
     var flagMask =
       if (ctx.settings.YdebugFlags.value) AnyFlags
       else if (suppressKw) PrintableFlags &~ Private
@@ -697,13 +698,13 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   protected def filterModTextAnnots(annots: List[untpd.Tree]): List[untpd.Tree] = annots
 
   def optText(name: Name)(encl: Text => Text): Text =
-    if (name.isEmpty) "" else encl(toText(name))
+    if (name.isEmpty) "".toText else encl(toText(name))
 
   def optText[T >: Untyped](tree: Tree[T])(encl: Text => Text): Text =
-    if (tree.isEmpty) "" else encl(toText(tree))
+    if (tree.isEmpty) "".toText else encl(toText(tree))
 
   def optText[T >: Untyped](tree: List[Tree[T]])(encl: Text => Text): Text =
-    if (tree.exists(!_.isEmpty)) encl(blockText(tree)) else ""
+    if (tree.exists(!_.isEmpty)) encl(blockText(tree)) else "".toText
 
   override protected def ParamRefNameString(name: Name): String =
     name.invariantName.toString
@@ -711,18 +712,18 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   override protected def treatAsTypeParam(sym: Symbol): Boolean = sym is TypeParam
 
   override protected def treatAsTypeArg(sym: Symbol) =
-    sym.isType && (sym is ProtectedLocal) &&
-      (sym.allOverriddenSymbols exists (_ is TypeParam))
+    sym.isType && sym.isBoth(Protected, and = Local) &&
+      sym.allOverriddenSymbols.exists(_ is TypeParam)
 
   override def toText(sym: Symbol): Text = {
     if (sym.isImport)
       sym.infoOrCompleter match {
-        case info: Namer#Completer => return info.original.show
-        case info: ImportType => return s"import $info.expr.show"
+        case info: Namer#Completer => return info.original.show.toText
+        case info: ImportType => return s"import $info.expr.show".toText
         case _ =>
       }
     if (sym.is(ModuleClass))
-      kindString(sym) ~~ (nameString(sym.name.stripModuleClassSuffix) + idString(sym))
+      kindString(sym).toText ~~ (nameString(sym.name.stripModuleClassSuffix) + idString(sym))
     else
       super.toText(sym)
   }
@@ -755,12 +756,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     else {
       var flags = sym.flagsUNSAFE
       if (flags is TypeParam) flags = flags &~ Protected
-      Text((flags & PrintableFlags).flagStrings map (flag => stringToText(keywordStr(flag))), " ")
+      Text((flags & PrintableFlags).flagStrings map (flag => keywordStr(flag).toText), " ")
     }
 
   override def toText(denot: Denotation): Text = denot match {
     case denot: MultiDenotation => Text(denot.alternatives.map(dclText), " <and> ")
-    case NoDenotation => "NoDenotation"
+    case NoDenotation => "NoDenotation".toText
     case _ =>
       if (denot.symbol.exists) toText(denot.symbol)
       else "some " ~ toText(denot.info)
@@ -768,10 +769,11 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
   override def plain = new PlainPrinter(_ctx)
 
-  private def withPos(txt: Text, pos: SourcePosition): Text = {
-    if (!printLines || !pos.exists) txt
+  private def withPos(txt: Text, pos: Position): Text = {
+    val spos = sourcePos(pos)
+    if (!printLines || !spos.exists) txt
     else txt match {
-      case Str(s, _) => Str(s, LineRange(pos.line, pos.endLine))
+      case Str(s, _) => Str(s, LineRange(spos.line, spos.endLine))
       case _ => txt
     }
   }
diff --git a/compiler/src/dotty/tools/dotc/printing/ReplPrinter.scala b/compiler/src/dotty/tools/dotc/printing/ReplPrinter.scala
index acd43d1848f7..91f41dc2c5c5 100644
--- a/compiler/src/dotty/tools/dotc/printing/ReplPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/ReplPrinter.scala
@@ -22,8 +22,8 @@ class ReplPrinter(_ctx: Context) extends DecompilerPrinter(_ctx) {
     ": " ~ toText(tp.resType)
 
   override def toText(sym: Symbol): Text =
-    if (sym.name.isReplAssignName) nameString(sym.name)
-    else keyString(sym) ~~ nameString(sym.name.stripModuleClassSuffix)
+    if (sym.name.isReplAssignName) nameString(sym.name).toText
+    else keyString(sym).toText ~~ nameString(sym.name.stripModuleClassSuffix)
 
   override def toText(const: Constant): Text =
     if (const.tag == Constants.StringTag) Str('"' + const.value.toString + '"')
@@ -33,8 +33,8 @@ class ReplPrinter(_ctx: Context) extends DecompilerPrinter(_ctx) {
     toText(sym) ~ {
       if (sym.is(Method)) toText(sym.info)
       else if (sym.isType && sym.info.isInstanceOf[TypeAlias]) toText(sym.info)
-      else if (sym.isType || sym.isClass) ""
-      else ":" ~~ toText(sym.info)
+      else if (sym.isType || sym.isClass) "".toText
+      else ":".toText ~~ toText(sym.info)
     }
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/printing/Showable.scala b/compiler/src/dotty/tools/dotc/printing/Showable.scala
index efddb26f7f13..e96668e57b9e 100644
--- a/compiler/src/dotty/tools/dotc/printing/Showable.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Showable.scala
@@ -18,7 +18,7 @@ trait Showable extends Any {
   /** A fallback text representation, if the pattern matching
    *  in Printers does not have a case for this showable element
    */
-  def fallbackToText(printer: Printer): Text = toString
+  def fallbackToText(printer: Printer): Text = toString.toText
 
   /** The string representation of this showable element. */
   def show(implicit ctx: Context): String = toText(ctx.printer).show
diff --git a/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala b/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala
index 902c7c14ef68..284e0e4cf610 100644
--- a/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala
+++ b/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala
@@ -8,6 +8,7 @@ import scala.collection.mutable.StringBuilder
 import core.Contexts.Context
 import util.Chars
 import Highlighting.{Highlight, HighlightBuffer}
+import dotty.tools.dotc.printing.Texts._
 
 /** This object provides functions for syntax highlighting in the REPL */
 object SyntaxHighlighting {
diff --git a/compiler/src/dotty/tools/dotc/printing/Texts.scala b/compiler/src/dotty/tools/dotc/printing/Texts.scala
index 41e91a5957a1..bbe81976d0f3 100644
--- a/compiler/src/dotty/tools/dotc/printing/Texts.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Texts.scala
@@ -1,6 +1,5 @@
 package dotty.tools.dotc
 package printing
-import language.implicitConversions
 
 object Texts {
 
@@ -84,7 +83,7 @@ object Texts {
 
     def stripPrefix(pre: String): Text = this match {
       case Str(s, _) =>
-        if (s.startsWith(pre)) s drop pre.length else s
+        (if (s.startsWith(pre)) s drop pre.length else s).toText
       case Fluid(relems) =>
         val elems = relems.reverse
         val head = elems.head.stripPrefix(pre)
@@ -133,12 +132,15 @@ object Texts {
       sb.toString
     }
 
-    def ~ (that: Text) =
+    def ~ (that: String): Text = this ~ that.toText
+    def ~~ (that: String): Text = this ~~ that.toText
+
+    def ~ (that: Text): Text =
       if (this.isEmpty) that
       else if (that.isEmpty) this
       else Fluid(that :: this :: Nil)
 
-    def ~~ (that: Text) =
+    def ~~ (that: Text): Text =
       if (this.isEmpty) that
       else if (that.isEmpty) this
       else Fluid(that :: Str(" ") :: this :: Nil)
@@ -161,7 +163,7 @@ object Texts {
       else {
         val ys = xs filterNot (_.isEmpty)
         if (ys.isEmpty) Str("")
-        else ys reduce (_ ~ sep ~ _)
+        else ys reduce (_ ~ sep.toText ~ _)
       }
     }
 
@@ -182,8 +184,6 @@ object Texts {
 
   class Closed(relems: List[Text]) extends Fluid(relems)
 
-  implicit def stringToText(s: String): Text = Str(s)
-
   /** Inclusive line range */
   case class LineRange(start: Int, end: Int) {
     def union(that: LineRange): LineRange = LineRange(start min that.start, end max that.end)
@@ -194,4 +194,9 @@ object Texts {
   }
 
   object EmptyLineRange extends LineRange(Int.MaxValue, Int.MinValue)
+
+  implicit class StringToText(val s: String) extends AnyVal {
+    def toText: Text = Str(s)
+    def ~ (that: Text): Text = Str(s) ~ that
+  }
 }
diff --git a/compiler/src/dotty/tools/dotc/quoted/ExprCompiler.scala b/compiler/src/dotty/tools/dotc/quoted/ExprCompiler.scala
index fb782c031543..c01053982f1b 100644
--- a/compiler/src/dotty/tools/dotc/quoted/ExprCompiler.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/ExprCompiler.scala
@@ -76,9 +76,9 @@ class ExprCompiler(directory: AbstractFile) extends Compiler {
       val assocFile = new PlainFile(Path("<quote>"))
 
       val cls = ctx.newCompleteClassSymbol(defn.RootClass, outputClassName, EmptyFlags,
-        defn.ObjectType :: Nil, newScope, coord = pos, assocFile = assocFile).entered.asClass
+        defn.ObjectType :: Nil, newScope, coord = pos.toCoord, assocFile = assocFile).entered.asClass
       cls.enter(ctx.newDefaultConstructor(cls), EmptyScope)
-      val meth = ctx.newSymbol(cls, nme.apply, Method, ExprType(defn.AnyType), coord = pos).entered
+      val meth = ctx.newSymbol(cls, nme.apply, Method, ExprType(defn.AnyType), coord = pos.toCoord).entered
 
       val quoted = PickledQuotes.quotedExprToTree(expr)(ctx.withOwner(meth))
 
diff --git a/compiler/src/dotty/tools/dotc/reporting/Reporter.scala b/compiler/src/dotty/tools/dotc/reporting/Reporter.scala
index 73443871c2bb..284542ee358a 100644
--- a/compiler/src/dotty/tools/dotc/reporting/Reporter.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/Reporter.scala
@@ -3,8 +3,10 @@ package dotc
 package reporting
 
 import core.Contexts._
+import util.Positions
+import Positions.{Position, NoPosition}
 import util.{SourcePosition, NoSourcePosition}
-import core.Decorators.PhaseListDecorator
+import core.Decorators.{PhaseListDecorator, sourcePos}
 import collection.mutable
 import java.lang.System.currentTimeMillis
 import core.Mode
@@ -30,11 +32,11 @@ import Reporter._
 trait Reporting { this: Context =>
 
   /** For sending messages that are printed only if -verbose is set */
-  def inform(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
+  def inform(msg: => String, pos: Position = NoPosition): Unit =
     if (this.settings.verbose.value) this.echo(msg, pos)
 
-  def echo(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
-    reporter.report(new Info(msg, pos))
+  def echo(msg: => String, pos: Position = NoPosition): Unit =
+    reporter.report(new Info(msg, sourcePos(pos)))
 
   def reportWarning(warning: Warning): Unit =
     if (!this.settings.silentWarnings.value) {
@@ -42,20 +44,26 @@ trait Reporting { this: Context =>
       else  reporter.report(warning)
     }
 
-  def deprecationWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
-    reportWarning(new DeprecationWarning(msg, pos))
+  def deprecationWarning(msg: => Message, pos: SourcePosition): Unit = reportWarning(new DeprecationWarning(msg, pos))
+  def deprecationWarning(msg: => Message, pos: Position = NoPosition): Unit = deprecationWarning(msg, sourcePos(pos))
 
-  def migrationWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
-    reportWarning(new MigrationWarning(msg, pos))
+  def migrationWarning(msg: => Message, pos: SourcePosition): Unit = reportWarning(new MigrationWarning(msg, pos))
+  def migrationWarning(msg: => Message, pos: Position = NoPosition): Unit = migrationWarning(msg, sourcePos(pos))
 
-  def uncheckedWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
-    reportWarning(new UncheckedWarning(msg, pos))
+  def warning(msg: => Message, pos: SourcePosition): Unit = reportWarning(new Warning(msg, pos))
+  def warning(msg: => Message, pos: Position = NoPosition): Unit = warning(msg, sourcePos(pos))
 
-  def featureWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
-    reportWarning(new FeatureWarning(msg, pos))
+  def error(msg: => Message, pos: SourcePosition): Unit = reporter.report(new Error(msg, pos))
+  def error(msg: => Message, pos: Position = NoPosition): Unit = error(msg, sourcePos(pos))
+
+  def uncheckedWarning(msg: => Message, pos: Position = NoPosition): Unit =
+    reportWarning(new UncheckedWarning(msg, sourcePos(pos)))
+
+  def featureWarning(msg: => Message, pos: Position = NoPosition): Unit =
+    reportWarning(new FeatureWarning(msg, sourcePos(pos)))
 
   def featureWarning(feature: String, featureDescription: String, isScala2Feature: Boolean,
-      featureUseSite: Symbol, required: Boolean, pos: SourcePosition): Unit = {
+      featureUseSite: Symbol, required: Boolean, pos: Position): Unit = {
     val req = if (required) "needs to" else "should"
     val prefix = if (isScala2Feature) "scala." else "dotty."
     val fqname = prefix + "language." + feature
@@ -74,25 +82,19 @@ trait Reporting { this: Context =>
 
     val msg = s"$featureDescription $req be enabled\nby making the implicit value $fqname visible.$explain"
     if (required) error(msg, pos)
-    else reportWarning(new FeatureWarning(msg, pos))
+    else reportWarning(new FeatureWarning(msg, sourcePos(pos)))
   }
 
-  def warning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
-    reportWarning(new Warning(msg, pos))
-
-  def strictWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
+  def strictWarning(msg: => Message, pos: Position = NoPosition): Unit =
     if (this.settings.strict.value) error(msg, pos)
-    else reportWarning(new ExtendMessage(() => msg)(_ + "\n(This would be an error under strict mode)").warning(pos))
-
-  def error(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
-    reporter.report(new Error(msg, pos))
+    else reportWarning(new ExtendMessage(() => msg)(_ + "\n(This would be an error under strict mode)").warning(sourcePos(pos)))
 
-  def errorOrMigrationWarning(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
+  def errorOrMigrationWarning(msg: => Message, pos: Position = NoPosition): Unit =
     if (ctx.scala2Mode) migrationWarning(msg, pos) else error(msg, pos)
 
-  def restrictionError(msg: => Message, pos: SourcePosition = NoSourcePosition): Unit =
+  def restrictionError(msg: => Message, pos: Position = NoPosition): Unit =
     reporter.report {
-      new ExtendMessage(() => msg)(m => s"Implementation restriction: $m").error(pos)
+      new ExtendMessage(() => msg)(m => s"Implementation restriction: $m").error(sourcePos(pos))
     }
 
   def incompleteInputError(msg: => Message, pos: SourcePosition = NoSourcePosition)(implicit ctx: Context): Unit =
@@ -102,7 +104,7 @@ trait Reporting { this: Context =>
    *  See [[config.CompilerCommand#explainAdvanced]] for the exact meaning of
    *  "contains" here.
    */
-  def log(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
+  def log(msg: => String, pos: Position = NoPosition): Unit =
     if (this.settings.Ylog.value.containsPhase(phase))
       echo(s"[log ${ctx.phasesStack.reverse.mkString(" -> ")}] $msg", pos)
 
@@ -122,7 +124,7 @@ trait Reporting { this: Context =>
     value
   }
 
-  def debugwarn(msg: => String, pos: SourcePosition = NoSourcePosition): Unit =
+  def debugwarn(msg: => String, pos: Position = NoPosition): Unit =
     if (this.settings.Ydebug.value) warning(msg, pos)
 }
 
diff --git a/compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala b/compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala
index c98e219a027a..005c40d6904c 100644
--- a/compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala
@@ -1828,7 +1828,7 @@ object messages {
     val kind = "Compatibility"
     val msg = "Failure to eliminate existential type. Proceed at own risk."
     val explanation = {
-      val originalType = ctx.dclsText(boundSyms, "; ").show
+      val originalType = ctx.printer.dclsText(boundSyms, "; ").show
       hl"""original type    : $tp forSome ${originalType}
           |reduces to       : $tp1
           |type used instead: $tp2"""
@@ -1968,7 +1968,7 @@ object messages {
 
     val msg = {
       val denotationOwner = denot.owner
-      val denotationName = ctx.fresh.setSetting(ctx.settings.YdebugNames, true).nameString(denot.name)
+      val denotationName = ctx.fresh.setSetting(ctx.settings.YdebugNames, true).printer.nameString(denot.name)
       val file = denot.symbol.associatedFile
       val (location, src) =
         if (file != null) (s" in $file", file.toString)
diff --git a/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala b/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala
index 312e2d4093db..74c254a150a1 100644
--- a/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala
+++ b/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala
@@ -520,9 +520,9 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
     // but their `privateWithin` exists, see `Parsers#ParserCommon#normalize`.
     if (!sym.is(Protected | Private) && !sym.privateWithin.exists)
       Constants.public
-    else if (sym.is(PrivateLocal))
+    else if (sym.isBoth(Private, and = Local))
       Constants.privateLocal
-    else if (sym.is(ProtectedLocal))
+    else if (sym.isBoth(Protected, and = Local))
       Constants.protectedLocal
     else {
       val qualifier =
diff --git a/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala b/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala
index e208902d3589..83ad48b26b1b 100644
--- a/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala
+++ b/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala
@@ -92,7 +92,7 @@ class AugmentScala2Traits extends MiniPhase with IdentityDenotTransformer with F
           else if (!sym.is(Deferred) && !sym.setter.exists &&
                    !sym.info.resultType.isInstanceOf[ConstantType])
             traitSetter(sym.asTerm).enteredAfter(thisPhase)
-        if ((sym.is(PrivateAccessor) && !sym.name.is(ExpandedName) &&
+        if ((sym.isBoth(Private, and = Accessor) && !sym.name.is(ExpandedName) &&
           (sym.isGetter || sym.isSetter)) // strangely, Scala 2 fields are also methods that have Accessor set.
           || sym.isSuperAccessor) // scala2 superaccessors are pickled as private, but are compiled as public expanded
           sym.ensureNotPrivate.installAfter(thisPhase)
diff --git a/compiler/src/dotty/tools/dotc/transform/Bridges.scala b/compiler/src/dotty/tools/dotc/transform/Bridges.scala
index 445dd2d58a65..4eb8f1883535 100644
--- a/compiler/src/dotty/tools/dotc/transform/Bridges.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Bridges.scala
@@ -81,8 +81,8 @@ class Bridges(root: ClassSymbol)(implicit ctx: Context) {
       owner = root,
       flags = (member.flags | Method | Bridge | Artifact) &~
         (Accessor | ParamAccessor | CaseAccessor | Deferred | Lazy | Module),
-      coord = bridgePosFor(member))
-      .enteredAfter(ctx.erasurePhase.asInstanceOf[DenotTransformer]).asTerm
+      coord = bridgePosFor(member).toCoord)
+      .enteredAfter(ctx.base.erasurePhase.asInstanceOf[DenotTransformer]).asTerm
 
     ctx.debuglog(
       i"""generating bridge from ${other.showLocated}: ${other.info}
diff --git a/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala b/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala
index 071b41444bfc..c9d09a1313af 100644
--- a/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala
@@ -48,7 +48,7 @@ class CollectEntryPoints extends MiniPhase {
     def fail(msg: String, pos: Position = sym.pos) = {
       ctx.warning(sym.name +
         s" has a main method with parameter type Array[String], but ${sym.fullName} will not be a runnable program.\n  Reason: $msg",
-        sourcePos(sym.pos)
+        sym.pos
         // TODO: make this next claim true, if possible
         //   by generating valid main methods as static in module classes
         //   not sure what the jvm allows here
diff --git a/compiler/src/dotty/tools/dotc/transform/Constructors.scala b/compiler/src/dotty/tools/dotc/transform/Constructors.scala
index f90289a5af48..6e93774c1dbf 100644
--- a/compiler/src/dotty/tools/dotc/transform/Constructors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Constructors.scala
@@ -99,7 +99,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
    */
   override def checkPostCondition(tree: tpd.Tree)(implicit ctx: Context): Unit = {
     def emptyRhsOK(sym: Symbol) =
-      sym.is(LazyOrDeferred) || sym.isConstructor && sym.owner.is(NoInitsTrait)
+      sym.is(LazyOrDeferred) || sym.isConstructor && sym.owner.isBoth(NoInits, and = Trait)
     tree match {
       case tree: ValDef if tree.symbol.exists && tree.symbol.owner.isClass && !tree.symbol.is(Lazy) && !tree.symbol.hasAnnotation(defn.ScalaStaticAnnot) =>
         assert(tree.rhs.isEmpty, i"$tree: initializer should be moved to constructors")
@@ -119,9 +119,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
    *  constructor.
    */
   private def mightBeDropped(sym: Symbol)(implicit ctx: Context) =
-    sym.is(Private, butNot = MethodOrLazy) && !sym.is(MutableParamAccessor)
-
-  private final val MutableParamAccessor = allOf(Mutable, ParamAccessor)
+    sym.is(Private, butNot = MethodOrLazy) && !sym.isBoth(Mutable, and = ParamAccessor)
 
   override def transformTemplate(tree: Template)(implicit ctx: Context): Tree = {
     val cls = ctx.owner.asClass
@@ -273,7 +271,7 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
 
     val finalConstrStats = copyParams ::: mappedSuperCalls ::: lazyAssignments ::: stats
     val expandedConstr =
-      if (cls.is(NoInitsTrait)) {
+      if (cls.isBoth(NoInits, and = Trait)) {
         assert(finalConstrStats.isEmpty)
         constr
       }
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
index fa185896ecfc..815a437443e7 100644
--- a/compiler/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -445,7 +445,7 @@ object Erasure {
       }
 
     private def runtimeCallWithProtoArgs(name: Name, pt: Type, args: Tree*)(implicit ctx: Context): Tree = {
-      val meth = defn.runtimeMethodRef(name)
+      val meth = defn.runtimeMethodRef(name.toTermName)
       val followingParams = meth.symbol.info.firstParamTypes.drop(args.length)
       val followingArgs = protoArgs(pt, meth.widen).zipWithConserve(followingParams)(typedExpr).asInstanceOf[List[tpd.Tree]]
       ref(meth).appliedToArgs(args.toList ++ followingArgs)
diff --git a/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala b/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala
index e5ee8556ec88..b9bce1367a36 100644
--- a/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala
@@ -64,7 +64,7 @@ class ExpandPrivate extends MiniPhase with IdentityDenotTransformer { thisPhase
   }
 
   private def isVCPrivateParamAccessor(d: SymDenotation)(implicit ctx: Context) =
-    d.isTerm && d.is(PrivateParamAccessor) && isDerivedValueClass(d.owner)
+    d.isTerm && d.isBoth(Private, and = ParamAccessor) && isDerivedValueClass(d.owner)
 
   /** Make private terms accessed from different classes non-private.
    *  Note: this happens also for accesses between class and linked module class.
@@ -109,7 +109,7 @@ class ExpandPrivate extends MiniPhase with IdentityDenotTransformer { thisPhase
     val sym = tree.symbol
     tree.rhs match {
       case Apply(sel @ Select(_: Super, _), _)
-      if sym.is(PrivateParamAccessor) && sel.symbol.is(ParamAccessor) && sym.name == sel.symbol.name =>
+      if sym.isBoth(Private, and = ParamAccessor) && sel.symbol.is(ParamAccessor) && sym.name == sel.symbol.name =>
         sym.ensureNotPrivate.installAfter(thisPhase)
       case _ =>
         if (isVCPrivateParamAccessor(sym))
diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
index 3240300d8f52..4ff3b89dccf6 100644
--- a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
+++ b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -49,7 +49,7 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
     addCompanionPhases.exists(_.isCompanionNeeded(cls))
 
   override def prepareForUnit(tree: Tree)(implicit ctx: Context) = {
-    addCompanionPhases = ctx.phasePlan.flatMap(_ collect { case p: NeedsCompanions => p })
+    addCompanionPhases = ctx.base.phasePlan.flatMap(_ collect { case p: NeedsCompanions => p })
     ctx
   }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala b/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala
index 228e73e1d5fa..fd6c977cd20c 100644
--- a/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala
+++ b/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala
@@ -43,7 +43,7 @@ class FunctionalInterfaces extends MiniPhase {
       val interfaceName = (functionName ++ implParamTypes.length.toString).specializedFor(implParamTypes ::: implResultType :: Nil, names, Nil, Nil)
 
       // symbols loaded from classpath aren't defined in periods earlier than when they where loaded
-      val interface = ctx.withPhase(ctx.typerPhase).requiredClass(functionPackage ++ interfaceName)
+      val interface = ctx.withPhase(ctx.typerPhase).requiredClass((functionPackage ++ interfaceName).toTypeName)
       val tpt = tpd.TypeTree(interface.asType.appliedRef)
       tpd.Closure(tree.env, tree.meth, tpt)
     } else tree
diff --git a/compiler/src/dotty/tools/dotc/transform/Getters.scala b/compiler/src/dotty/tools/dotc/transform/Getters.scala
index 55e68d69ff11..99df35501293 100644
--- a/compiler/src/dotty/tools/dotc/transform/Getters.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Getters.scala
@@ -54,7 +54,7 @@ class Getters extends MiniPhase with SymTransformer {
   override def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = {
     def noGetterNeeded =
       d.is(NoGetterNeeded) ||
-      d.initial.asInstanceOf[SymDenotation].is(PrivateLocal) && !d.owner.is(Trait) && !isDerivedValueClass(d.owner) && !d.is(Flags.Lazy) ||
+      d.initial.asInstanceOf[SymDenotation].isBoth(Private, and = Local) && !d.owner.is(Trait) && !isDerivedValueClass(d.owner) && !d.is(Flags.Lazy) ||
       d.is(Module) && d.isStatic ||
       d.hasAnnotation(defn.ScalaStaticAnnot) ||
       d.isSelfSym
diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
index 2d22dea0d86f..b4749f9d1f16 100644
--- a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -143,8 +143,8 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
 
         val holderImpl = ctx.requiredClass("dotty.runtime." + holderType)
 
-        val holderSymbol = ctx.newSymbol(x.symbol.owner, holderName, containerFlags, holderImpl.typeRef, coord = x.pos)
-        val initSymbol = ctx.newSymbol(x.symbol.owner, initName, initFlags, MethodType(Nil, tpe), coord = x.pos)
+        val holderSymbol = ctx.newSymbol(x.symbol.owner, holderName, containerFlags, holderImpl.typeRef, coord = x.coord)
+        val initSymbol = ctx.newSymbol(x.symbol.owner, initName, initFlags, MethodType(Nil, tpe), coord = x.coord)
         val result = ref(holderSymbol).select(lazyNme.value).withPos(x.pos)
         val flag = ref(holderSymbol).select(lazyNme.initialized)
         val initer = valueInitter.changeOwnerAfter(x.symbol, initSymbol, this)
diff --git a/compiler/src/dotty/tools/dotc/transform/LiftTry.scala b/compiler/src/dotty/tools/dotc/transform/LiftTry.scala
index f42131b88153..7c14330228df 100644
--- a/compiler/src/dotty/tools/dotc/transform/LiftTry.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LiftTry.scala
@@ -62,7 +62,7 @@ class LiftTry extends MiniPhase with IdentityDenotTransformer { thisPhase =>
       ctx.debuglog(i"lifting tree at ${tree.pos}, current owner = ${ctx.owner}")
       val fn = ctx.newSymbol(
         ctx.owner, LiftedTreeName.fresh(), Synthetic | Method,
-        MethodType(Nil, tree.tpe.widenIfUnstable), coord = tree.pos)
+        MethodType(Nil, tree.tpe.widenIfUnstable), coord = tree.coord)
       tree.changeOwnerAfter(ctx.owner, fn, thisPhase)
       Block(DefDef(fn, tree) :: Nil, ref(fn).appliedToNone)
     }
diff --git a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala
index 4b1b93ab63f4..715e0500fca0 100644
--- a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala
@@ -77,7 +77,7 @@ class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisPhas
     def currentClass = ctx.owner.enclosingClass.asClass
     app match {
       case Apply(sel @ Select(Super(_, _), _), args)
-      if sel.symbol.owner.is(Scala2xTrait) && currentClass.mixins.contains(sel.symbol.owner) =>
+      if sel.symbol.owner.isBoth(Scala2x, and = Trait) && currentClass.mixins.contains(sel.symbol.owner) =>
         val impl = implMethod(sel.symbol)
         if (impl.exists) Apply(ref(impl), This(currentClass) :: args).withPos(app.pos)
         else app // could have been an abstract method in a trait linked to from a super constructor
@@ -105,6 +105,4 @@ class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisPhas
           .symbol
     else throw new AssertionError(i"no impl method for $meth")
   }
-
-  private val Scala2xTrait = allOf(Scala2x, Trait)
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/Memoize.scala b/compiler/src/dotty/tools/dotc/transform/Memoize.scala
index 1f9ffcdf2eba..6211e0ced021 100644
--- a/compiler/src/dotty/tools/dotc/transform/Memoize.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Memoize.scala
@@ -80,7 +80,7 @@ import Decorators._
         name  = sym.name.asTermName.fieldName,
         flags = Private | (if (sym is Stable) EmptyFlags else Mutable),
         info  = fieldType,
-        coord = tree.pos
+        coord = tree.coord
       ).withAnnotationsCarrying(sym, defn.FieldMetaAnnot)
        .enteredAfter(thisPhase)
     }
diff --git a/compiler/src/dotty/tools/dotc/transform/Mixin.scala b/compiler/src/dotty/tools/dotc/transform/Mixin.scala
index c3236872d607..cfc3b806bfac 100644
--- a/compiler/src/dotty/tools/dotc/transform/Mixin.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Mixin.scala
@@ -179,10 +179,10 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
 
     def superCallOpt(baseCls: Symbol): List[Tree] = superCalls.get(baseCls) match {
       case Some(call) =>
-        if (defn.NotRuntimeClasses.contains(baseCls) || baseCls.is(NoInitsTrait)) Nil
+        if (defn.NotRuntimeClasses.contains(baseCls) || baseCls.isBoth(NoInits, and = Trait)) Nil
         else call :: Nil
       case None =>
-        if (baseCls.is(NoInitsTrait) || defn.NoInitClasses.contains(baseCls) || defn.isFunctionClass(baseCls)) Nil
+        if (baseCls.isBoth(NoInits, and = Trait) || defn.NoInitClasses.contains(baseCls) || defn.isFunctionClass(baseCls)) Nil
         else {
           //println(i"synth super call ${baseCls.primaryConstructor}: ${baseCls.primaryConstructor.info}")
           transformFollowingDeep(superRef(baseCls.primaryConstructor).appliedToNone) :: Nil
diff --git a/compiler/src/dotty/tools/dotc/transform/MixinOps.scala b/compiler/src/dotty/tools/dotc/transform/MixinOps.scala
index d3e08d7f9b7e..82aefd6c6658 100644
--- a/compiler/src/dotty/tools/dotc/transform/MixinOps.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MixinOps.scala
@@ -15,7 +15,7 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
   val mixins: List[ClassSymbol] = cls.mixins
 
   lazy val JUnit4Annotations: List[Symbol] = List("Test", "Ignore", "Before", "After", "BeforeClass", "AfterClass").
-    map(n => ctx.getClassIfDefined("org.junit." + n)).
+    map(n => ctx.getClassIfDefined(s"org.junit.$n".toTypeName)).
     filter(_.exists)
 
   def implementation(member: TermSymbol): TermSymbol = {
diff --git a/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala b/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala
index 18eb68f0c9fd..9e76461c1a04 100644
--- a/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala
+++ b/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala
@@ -39,7 +39,7 @@ class NonLocalReturns extends MiniPhase {
   private def nonLocalReturnKey(meth: Symbol)(implicit ctx: Context) =
     nonLocalReturnKeys.getOrElseUpdate(meth,
       ctx.newSymbol(
-        meth, NonLocalReturnKeyName.fresh(), Synthetic, defn.ObjectType, coord = meth.pos))
+        meth, NonLocalReturnKeyName.fresh(), Synthetic, defn.ObjectType, coord = meth.coord))
 
   /** Generate a non-local return throw with given return expression from given method.
    *  I.e. for the method's non-local return key, generate:
@@ -70,7 +70,7 @@ class NonLocalReturns extends MiniPhase {
   private def nonLocalReturnTry(body: Tree, key: TermSymbol, meth: Symbol)(implicit ctx: Context) = {
     val keyDef = ValDef(key, New(defn.ObjectType, Nil))
     val nonLocalReturnControl = defn.NonLocalReturnControlType
-    val ex = ctx.newSymbol(meth, nme.ex, EmptyFlags, nonLocalReturnControl, coord = body.pos)
+    val ex = ctx.newSymbol(meth, nme.ex, EmptyFlags, nonLocalReturnControl, coord = body.coord)
     val pat = BindTyped(ex, nonLocalReturnControl)
     val rhs = If(
         ref(ex).select(nme.key).appliedToNone.select(nme.eq).appliedTo(ref(key)),
diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
index 9f1eae55ddde..65b5521500b9 100644
--- a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -85,7 +85,7 @@ object PatternMatcher {
 
     private def newVar(rhs: Tree, flags: FlagSet): TermSymbol =
       ctx.newSymbol(ctx.owner, PatMatStdBinderName.fresh(), Synthetic | Case | flags,
-        sanitize(rhs.tpe), coord = rhs.pos)
+        sanitize(rhs.tpe), coord = rhs.coord)
         // TODO: Drop Case once we use everywhere else `isPatmatGenerated`.
 
     /** The plan `let x = rhs in body(x)` where `x` is a fresh variable */
@@ -286,7 +286,7 @@ object PatternMatcher {
         lazy val caseAccessors = caseClass.caseAccessors.filter(_.is(Method))
 
         def isSyntheticScala2Unapply(sym: Symbol) =
-          sym.is(SyntheticCase) && sym.owner.is(Scala2x)
+          sym.isBoth(Synthetic, and = Case) && sym.owner.is(Scala2x)
 
         if (isSyntheticScala2Unapply(unapp.symbol) && caseAccessors.length == args.length)
           matchArgsPlan(caseAccessors.map(ref(scrutinee).select(_)), args, onSuccess)
diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcherOld.scala.disabled b/compiler/src/dotty/tools/dotc/transform/PatternMatcherOld.scala.disabled
index c0ab94b02386..4d7c5cd9ee44 100644
--- a/compiler/src/dotty/tools/dotc/transform/PatternMatcherOld.scala.disabled
+++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcherOld.scala.disabled
@@ -71,9 +71,8 @@ class PatternMatcherOld extends MiniPhase with DenotTransformer {
   trait CodegenCore {
 
     // assert(owner ne null); assert(owner ne NoSymbol)
-    def freshSym(pos: Position, tp: Type = NoType, unique: UniqueNameKind = PatMatStdBinderName, owner: Symbol = ctx.owner) = {
-      ctx.newSymbol(owner, unique.fresh(), Flags.Synthetic | Flags.Case, tp, coord = pos)
-    }
+    def freshSym(pos: Position, tp: Type = NoType, unique: UniqueNameKind = PatMatStdBinderName, owner: Symbol = ctx.owner) =
+      ctx.newSymbol(owner, unique.fresh(), Flags.Synthetic | Flags.Case, tp, coord = pos.toCoord)
 
     def newSynthCaseLabel(unique: UniqueNameKind, tpe: Type, owner: Symbol = ctx.owner) =
       ctx.newSymbol(owner, unique.fresh(), Flags.Label | Flags.Synthetic | Flags.Method, tpe).asTerm
@@ -1231,7 +1230,7 @@ class PatternMatcherOld extends MiniPhase with DenotTransformer {
       val pt = match_.tpe.widen //repeatedToSeq(origPt)
 
       // val packedPt = repeatedToSeq(typer.packedType(match_, context.owner))
-      selectorSym.setFlag(Flags.SyntheticCase)
+      selectorSym.setFlag(Flags.Synthetic | Flags.Case)
 
       // pt = Any* occurs when compiling test/files/pos/annotDepMethType.scala  with -Xexperimental
       val combined = combineCases(sel, selectorSym, nonSyntheticCases map translateCase(selectorSym, pt), pt, ctx.owner, defaultOverride)
diff --git a/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala b/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala
index 761d092da972..9e60d6c82c14 100644
--- a/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SelectStatic.scala
@@ -29,7 +29,7 @@ class SelectStatic extends MiniPhase with IdentityDenotTransformer {
       sym.hasAnnotation(ctx.definitions.ScalaStaticAnnot)
     val isStaticRef = !sym.is(Package) && !sym.maybeOwner.is(Package) && isStaticMember
     val tree1 =
-      if (isStaticRef && !tree.qualifier.symbol.is(JavaModule) && !tree.qualifier.isType)
+      if (isStaticRef && !tree.qualifier.symbol.isBoth(JavaDefined, and = Module) && !tree.qualifier.isType)
         Block(List(tree.qualifier), ref(sym))
       else tree
 
diff --git a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
index c13ce4a39303..5c51c24f9391 100644
--- a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
@@ -76,7 +76,6 @@ class SuperAccessors(thisPhase: DenotTransformer) {
       if (clazz is Trait) superName = superName.expandedName(clazz)
       val superInfo = sel.tpe.widenSingleton.ensureMethodic
 
-      val accPos = sel.pos.focus
       val superAcc = clazz.info.decl(superName)
         .suchThat(_.signature == superInfo.signature).symbol
         .orElse {
@@ -84,11 +83,11 @@ class SuperAccessors(thisPhase: DenotTransformer) {
           val maybeDeferred = if (clazz is Trait) Deferred else EmptyFlags
           val acc = ctx.newSymbol(
               clazz, superName, Artifact | Method | maybeDeferred,
-              superInfo, coord = accPos).enteredAfter(thisPhase)
+              superInfo, coord = sel.coord).enteredAfter(thisPhase)
           // Diagnostic for SI-7091
           if (!accDefs.contains(clazz))
             ctx.error(s"Internal error: unable to store accessor definition in ${clazz}. clazz.hasPackageFlag=${clazz is Package}. Accessor required for ${sel} (${sel.show})", sel.pos)
-          else accDefs(clazz) += DefDef(acc, EmptyTree).withPos(accPos)
+          else accDefs(clazz) += DefDef(acc, EmptyTree).withPos(sel.pos.focus)
           acc
         }
 
@@ -104,7 +103,7 @@ class SuperAccessors(thisPhase: DenotTransformer) {
       assert(sup.symbol.exists, s"missing symbol in $sel: ${sup.tpe}")
       val clazz = sup.symbol
 
-      if (sym.isTerm && !sym.is(Method, butNot = Accessor) && !ctx.owner.is(ParamForwarder))
+      if (sym.isTerm && !sym.is(Method, butNot = Accessor) && !ctx.owner.isParamForwarder)
         // ParamForwaders as installed ParamForwarding.scala do use super calls to vals
         ctx.error(s"super may be not be used on ${sym.underlyingSymbol}", sel.pos)
       else if (isDisallowed(sym))
@@ -182,14 +181,13 @@ class SuperAccessors(thisPhase: DenotTransformer) {
         }
         accTypeOf(sym.info)
       }
-      val accPos = sel.pos.focus
       val protectedAccessor = clazz.info.decl(accName).suchThat(_.signature == accType.signature).symbol orElse {
         val newAcc = ctx.newSymbol(
-          clazz, accName, Artifact | Method, accType, coord = accPos).enteredAfter(thisPhase)
+          clazz, accName, Artifact | Method, accType, coord = sel.coord).enteredAfter(thisPhase)
         val code = polyDefDef(newAcc, trefs => vrefss => {
           val (receiver :: _) :: tail = vrefss
           val base = receiver.select(sym).appliedToTypes(trefs)
-          (base /: tail)(Apply(_, _)).withPos(accPos)
+          (base /: tail)(Apply(_, _)).withPos(sel.pos.focus)
         })
         ctx.debuglog("created protected accessor: " + code)
         accDefs(clazz) += code
@@ -235,14 +233,13 @@ class SuperAccessors(thisPhase: DenotTransformer) {
           MethodType(receiverType :: Nil)(mt => tpe.substThis(sym.owner.asClass, mt.newParamRef(0)))
       }
       val accType = accTypeOf(sym.info)
-      val accPos = tree.pos.focus
       val protectedAccessor = clazz.info.decl(accName).suchThat(_.signature == accType.signature).symbol orElse {
         val newAcc = ctx.newSymbol(
-            clazz, accName, Artifact, accType, coord = accPos).enteredAfter(thisPhase)
+            clazz, accName, Artifact, accType, coord = tree.coord).enteredAfter(thisPhase)
         val code = polyDefDef(newAcc, trefs => vrefss => {
           val (receiver :: _) :: tail = vrefss
           val base = receiver.select(sym).appliedToTypes(trefs)
-          (base /: vrefss)(Apply(_, _)).withPos(accPos)
+          (base /: vrefss)(Apply(_, _)).withPos(tree.pos.focus)
         })
         ctx.debuglog("created protected accessor: " + code)
         accDefs(clazz) += code
@@ -268,13 +265,12 @@ class SuperAccessors(thisPhase: DenotTransformer) {
 
       val accName = ProtectedSetterName(field.name)
       val accType = MethodType(clazz.classInfo.selfType :: field.info :: Nil, defn.UnitType)
-      val accPos = tree.pos.focus
       val protectedAccessor = clazz.info.decl(accName).symbol orElse {
         val newAcc = ctx.newSymbol(
-            clazz, accName, Artifact | Method, accType, coord = accPos).enteredAfter(thisPhase)
+            clazz, accName, Artifact | Method, accType, coord = tree.coord).enteredAfter(thisPhase)
         val code = DefDef(newAcc, vrefss => {
           val (receiver :: value :: Nil) :: Nil = vrefss
-          Assign(receiver.select(field), value).withPos(accPos)
+          Assign(receiver.select(field), value).withPos(tree.pos.focus)
         })
         ctx.debuglog("created protected setter: " + code)
         accDefs(clazz) += code
diff --git a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
index c30fa18a807e..1be788c79b1f 100644
--- a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
@@ -18,169 +18,164 @@ import language.implicitConversions
 import scala.annotation.tailrec
 
 object SymUtils {
-  implicit def decorateSymbol(sym: Symbol): SymUtils = new SymUtils(sym)
-  implicit def decorateSymDenot(d: SymDenotation): SymUtils = new SymUtils(d.symbol)
-}
-
-/** A decorator that provides methods on symbols
- *  that are needed in the transformer pipeline.
- */
-class SymUtils(val self: Symbol) extends AnyVal {
-  import SymUtils._
-
-  /** All traits implemented by a class or trait except for those inherited through the superclass. */
-  def directlyInheritedTraits(implicit ctx: Context) = {
-    val superCls = self.asClass.superClass
-    val baseClasses = self.asClass.baseClasses
-    if (baseClasses.isEmpty) Nil
-    else baseClasses.tail.takeWhile(_ ne superCls).reverse
-  }
-
-  /** All traits implemented by a class, except for those inherited through the superclass.
-   *  The empty list if `self` is a trait.
+  /** A decorator that provides methods on symbols
+   *  that are needed in the transformer pipeline.
    */
-  def mixins(implicit ctx: Context) = {
-    if (self is Trait) Nil
-    else directlyInheritedTraits
-  }
+  implicit class SymUtilsOps(val self: Symbol) extends AnyVal {
+    /** All traits implemented by a class or trait except for those inherited through the superclass. */
+    def directlyInheritedTraits(implicit ctx: Context) = {
+      val superCls = self.asClass.superClass
+      val baseClasses = self.asClass.baseClasses
+      if (baseClasses.isEmpty) Nil
+      else baseClasses.tail.takeWhile(_ ne superCls).reverse
+    }
 
-  def isTypeTest(implicit ctx: Context): Boolean =
-    self == defn.Any_isInstanceOf || self == defn.Any_typeTest
+    /** All traits implemented by a class, except for those inherited through the superclass.
+     *  The empty list if `self` is a trait.
+     */
+    def mixins(implicit ctx: Context) = {
+      if (self is Trait) Nil
+      else directlyInheritedTraits
+    }
 
-  def isTypeTestOrCast(implicit ctx: Context): Boolean =
-    self == defn.Any_asInstanceOf || isTypeTest
+    def isTypeTest(implicit ctx: Context): Boolean =
+      self == defn.Any_isInstanceOf || self == defn.Any_typeTest
 
-  def isVolatile(implicit ctx: Context) = self.hasAnnotation(defn.VolatileAnnot)
+    def isTypeTestOrCast(implicit ctx: Context): Boolean =
+      self == defn.Any_asInstanceOf || isTypeTest
 
-  def isAnyOverride(implicit ctx: Context) = self.is(Override) || self.is(AbsOverride)
-    // careful: AbsOverride is a term only flag. combining with Override would catch only terms.
+    def isVolatile(implicit ctx: Context) = self.hasAnnotation(defn.VolatileAnnot)
 
-  def isSuperAccessor(implicit ctx: Context) = self.name.is(SuperAccessorName)
+    def isAnyOverride(implicit ctx: Context) = self.is(Override) || self.is(AbsOverride)
+      // careful: AbsOverride is a term only flag. combining with Override would catch only terms.
 
-  /** A type or term parameter or a term parameter accessor */
-  def isParamOrAccessor(implicit ctx: Context) =
-    self.is(Param) || self.is(ParamAccessor)
+    def isSuperAccessor(implicit ctx: Context) = self.name.is(SuperAccessorName)
 
-  /** If this is a constructor, its owner: otherwise this. */
-  final def skipConstructor(implicit ctx: Context): Symbol =
-    if (self.isConstructor) self.owner else self
+    /** A type or term parameter or a term parameter accessor */
+    def isParamOrAccessor(implicit ctx: Context) =
+      self.is(Param) || self.is(ParamAccessor)
 
-  /** The closest properly enclosing method or class of this symbol. */
-  final def enclosure(implicit ctx: Context) = {
-    self.owner.enclosingMethodOrClass
-  }
+    /** If this is a constructor, its owner: otherwise this. */
+    final def skipConstructor(implicit ctx: Context): Symbol =
+      if (self.isConstructor) self.owner else self
 
-  /** The closest enclosing method or class of this symbol */
-  @tailrec final def enclosingMethodOrClass(implicit ctx: Context): Symbol =
-    if (self.is(Method, butNot = Label) || self.isClass) self
-    else if (self.exists) self.owner.enclosingMethodOrClass
-    else NoSymbol
-
-  /** Apply symbol/symbol substitution to this symbol */
-  def subst(from: List[Symbol], to: List[Symbol]): Symbol = {
-    @tailrec def loop(from: List[Symbol], to: List[Symbol]): Symbol =
-      if (from.isEmpty) self
-      else if (self eq from.head) to.head
-      else loop(from.tail, to.tail)
-    loop(from, to)
-  }
+    /** The closest properly enclosing method or class of this symbol. */
+    final def enclosure(implicit ctx: Context) = {
+      self.owner.enclosingMethodOrClass
+    }
 
-  def accessorNamed(name: TermName)(implicit ctx: Context): Symbol =
-    self.owner.info.decl(name).suchThat(_ is Accessor).symbol
+    /** The closest enclosing method or class of this symbol */
+    @tailrec final def enclosingMethodOrClass(implicit ctx: Context): Symbol =
+      if (self.is(Method, butNot = Label) || self.isClass) self
+      else if (self.exists) self.owner.enclosingMethodOrClass
+      else NoSymbol
+
+    /** Apply symbol/symbol substitution to this symbol */
+    def subst(from: List[Symbol], to: List[Symbol]): Symbol = {
+      @tailrec def loop(from: List[Symbol], to: List[Symbol]): Symbol =
+        if (from.isEmpty) self
+        else if (self eq from.head) to.head
+        else loop(from.tail, to.tail)
+      loop(from, to)
+    }
 
-  def paramAccessors(implicit ctx: Context): List[Symbol] =
-    self.info.decls.filter(_ is ParamAccessor)
+    def accessorNamed(name: TermName)(implicit ctx: Context): Symbol =
+      self.owner.info.decl(name).suchThat(_ is Accessor).symbol
 
-  def caseAccessors(implicit ctx: Context): List[Symbol] =
-    self.info.decls.filter(_ is CaseAccessor)
+    def paramAccessors(implicit ctx: Context): List[Symbol] =
+      self.info.decls.filter(_ is ParamAccessor)
 
-  def getter(implicit ctx: Context): Symbol =
-    if (self.isGetter) self else accessorNamed(self.asTerm.name.getterName)
+    def caseAccessors(implicit ctx: Context): List[Symbol] =
+      self.info.decls.filter(_ is CaseAccessor)
 
-  def setter(implicit ctx: Context): Symbol =
-    if (self.isSetter) self
-    else accessorNamed(self.asTerm.name.setterName)
+    def getter(implicit ctx: Context): Symbol =
+      if (self.isGetter) self else accessorNamed(self.asTerm.name.getterName)
 
-  def field(implicit ctx: Context): Symbol = {
-    val thisName = self.name.asTermName
-    val fieldName =
-      if (self.hasAnnotation(defn.ScalaStaticAnnot)) thisName.getterName
-      else thisName.fieldName
-    self.owner.info.decl(fieldName).suchThat(!_.is(Method)).symbol
-  }
+    def setter(implicit ctx: Context): Symbol =
+      if (self.isSetter) self
+      else accessorNamed(self.asTerm.name.setterName)
+
+    def field(implicit ctx: Context): Symbol = {
+      val thisName = self.name.asTermName
+      val fieldName =
+        if (self.hasAnnotation(defn.ScalaStaticAnnot)) thisName.getterName
+        else thisName.fieldName
+      self.owner.info.decl(fieldName).suchThat(!_.is(Method)).symbol
+    }
 
-  def isField(implicit ctx: Context): Boolean =
-    self.isTerm && !self.is(Method)
+    def isField(implicit ctx: Context): Boolean =
+      self.isTerm && !self.is(Method)
 
-  def implClass(implicit ctx: Context): Symbol =
-    self.owner.info.decl(self.name.implClassName).symbol
+    def implClass(implicit ctx: Context): Symbol =
+      self.owner.info.decl(self.name.implClassName).symbol
 
-  def traitOfImplClass(implicit ctx: Context): Symbol =
-    self.owner.info.decl(self.name.traitOfImplClassName).symbol
+    def traitOfImplClass(implicit ctx: Context): Symbol =
+      self.owner.info.decl(self.name.traitOfImplClassName).symbol
 
-  def annotationsCarrying(meta: ClassSymbol)(implicit ctx: Context): List[Annotation] =
-    self.annotations.filter(_.symbol.hasAnnotation(meta))
+    def annotationsCarrying(meta: ClassSymbol)(implicit ctx: Context): List[Annotation] =
+      self.annotations.filter(_.symbol.hasAnnotation(meta))
 
-  def withAnnotationsCarrying(from: Symbol, meta: ClassSymbol)(implicit ctx: Context): self.type = {
-    self.addAnnotations(from.annotationsCarrying(meta))
-    self
-  }
+    def withAnnotationsCarrying(from: Symbol, meta: ClassSymbol)(implicit ctx: Context): self.type = {
+      self.addAnnotations(from.annotationsCarrying(meta))
+      self
+    }
 
-  def registerCompanionMethod(name: Name, target: Symbol)(implicit ctx: Context) = {
-    if (!self.unforcedDecls.lookup(name).exists) {
-      val companionMethod = ctx.synthesizeCompanionMethod(name, target, self)
-      if (companionMethod.exists) {
-        companionMethod.entered
+    def registerCompanionMethod(name: Name, target: Symbol)(implicit ctx: Context) = {
+      if (!self.unforcedDecls.lookup(name).exists) {
+        val companionMethod = ctx.synthesizeCompanionMethod(name, target, self)
+        if (companionMethod.exists) {
+          companionMethod.entered
+        }
       }
     }
-  }
 
-  /** If this symbol is an enum value or a named class, register it as a child
-   *  in all direct parent classes which are sealed.
-   *   @param  @late  If true, register only inaccessible children (all others are already
-   *                  entered at this point).
-   */
-  def registerIfChild(late: Boolean = false)(implicit ctx: Context): Unit = {
-    def register(child: Symbol, parent: Type) = {
-      val cls = parent.classSymbol
-      if (cls.is(Sealed) && (!late || child.isInaccessibleChildOf(cls)))
-        cls.addAnnotation(Annotation.Child(child))
-    }
-    if (self.isClass && !self.isAnonymousClass)
-      self.asClass.classParents.foreach { parent =>
-        val child = if (self.is(Module)) self.sourceModule else self
-        register(child, parent)
+    /** If this symbol is an enum value or a named class, register it as a child
+     *  in all direct parent classes which are sealed.
+     *   @param  @late  If true, register only inaccessible children (all others are already
+     *                  entered at this point).
+     */
+    def registerIfChild(late: Boolean = false)(implicit ctx: Context): Unit = {
+      def register(child: Symbol, parent: Type) = {
+        val cls = parent.classSymbol
+        if (cls.is(Sealed) && (!late || child.isInaccessibleChildOf(cls)))
+          cls.addAnnotation(Annotation.Child(child))
       }
-    else if (self.is(CaseVal, butNot = Method | Module))
-      register(self, self.info)
-  }
+      if (self.isClass && !self.isAnonymousClass)
+        self.asClass.classParents.foreach { parent =>
+          val child = if (self.is(Module)) self.sourceModule else self
+          register(child, parent)
+        }
+      else if (self.is(CaseVal, butNot = Method | Module))
+        register(self, self.info)
+    }
 
-  /** Is this symbol defined locally (i.e. at some level owned by a term) and
-   *  defined in a different toplevel class than its supposed parent class `cls`?
-   *  Such children are not pickled, and have to be reconstituted manually.
-   */
-  def isInaccessibleChildOf(cls: Symbol)(implicit ctx: Context) =
-    self.isLocal && !cls.topLevelClass.isLinkedWith(self.topLevelClass)
+    /** Is this symbol defined locally (i.e. at some level owned by a term) and
+     *  defined in a different toplevel class than its supposed parent class `cls`?
+     *  Such children are not pickled, and have to be reconstituted manually.
+     */
+    def isInaccessibleChildOf(cls: Symbol)(implicit ctx: Context) =
+      self.isLocal && !cls.topLevelClass.isLinkedWith(self.topLevelClass)
+
+    /** If this is a sealed class, its known children */
+    def children(implicit ctx: Context): List[Symbol] =
+      self.annotations.collect {
+        case Annotation.Child(child) => child
+      }
 
-  /** If this is a sealed class, its known children */
-  def children(implicit ctx: Context): List[Symbol] =
-    self.annotations.collect {
-      case Annotation.Child(child) => child
+    /** Is symbol directly or indirectly owned by a term symbol? */
+    @tailrec def isLocal(implicit ctx: Context): Boolean = {
+      val owner = self.owner
+      if (owner.isTerm) true
+      else if (owner.is(Package)) false
+      else owner.isLocal
     }
 
-  /** Is symbol directly or indirectly owned by a term symbol? */
-  @tailrec def isLocal(implicit ctx: Context): Boolean = {
-    val owner = self.owner
-    if (owner.isTerm) true
-    else if (owner.is(Package)) false
-    else owner.isLocal
-  }
-
-  /** Is symbol a quote operation? */
-  def isQuote(implicit ctx: Context): Boolean =
-    self == defn.quoteMethod || self == defn.typeQuoteMethod
+    /** Is symbol a quote operation? */
+    def isQuote(implicit ctx: Context): Boolean =
+      self == defn.quoteMethod || self == defn.typeQuoteMethod
 
-  /** Is symbol a splice operation? */
-  def isSplice(implicit ctx: Context): Boolean =
-    self == defn.QuotedExpr_~ || self == defn.QuotedType_~
+    /** Is symbol a splice operation? */
+    def isSplice(implicit ctx: Context): Boolean =
+      self == defn.QuotedExpr_~ || self == defn.QuotedType_~
+  }
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/SyntheticMethods.scala b/compiler/src/dotty/tools/dotc/transform/SyntheticMethods.scala
index a5cf2447418c..f8c8080bc9d2 100644
--- a/compiler/src/dotty/tools/dotc/transform/SyntheticMethods.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SyntheticMethods.scala
@@ -83,7 +83,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
         coord = clazz.coord).enteredAfter(thisPhase).asTerm
 
       def forwardToRuntime(vrefss: List[List[Tree]]): Tree =
-        ref(defn.runtimeMethodRef("_" + sym.name.toString)).appliedToArgs(This(clazz) :: vrefss.head)
+        ref(defn.runtimeMethodRef(("_" + sym.name).toTermName)).appliedToArgs(This(clazz) :: vrefss.head)
 
       def ownName(vrefss: List[List[Tree]]): Tree =
         Literal(Constant(clazz.name.stripModuleClassSuffix.toString))
@@ -160,7 +160,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
      *  If `C` is a value class the initial `eq` test is omitted.
      */
     def equalsBody(that: Tree)(implicit ctx: Context): Tree = {
-      val thatAsClazz = ctx.newSymbol(ctx.owner, nme.x_0, Synthetic, clazzType, coord = ctx.owner.pos) // x$0
+      val thatAsClazz = ctx.newSymbol(ctx.owner, nme.x_0, Synthetic, clazzType, coord = ctx.owner.coord) // x$0
       def wildcardAscription(tp: Type) = Typed(Underscore(tp), TypeTree(tp))
       val pattern = Bind(thatAsClazz, wildcardAscription(clazzType)) // x$0 @ (_: C)
       val comparisons = accessors map { accessor =>
@@ -215,11 +215,11 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
     def caseHashCodeBody(implicit ctx: Context): Tree = {
       val seed = clazz.fullName.toString.hashCode
       if (accessors.nonEmpty) {
-        val acc = ctx.newSymbol(ctx.owner, "acc".toTermName, Mutable | Synthetic, defn.IntType, coord = ctx.owner.pos)
+        val acc = ctx.newSymbol(ctx.owner, "acc".toTermName, Mutable | Synthetic, defn.IntType, coord = ctx.owner.coord)
         val accDef = ValDef(acc, Literal(Constant(seed)))
         val mixes = for (accessor <- accessors) yield
-          Assign(ref(acc), ref(defn.staticsMethod("mix")).appliedTo(ref(acc), hashImpl(accessor)))
-        val finish = ref(defn.staticsMethod("finalizeHash")).appliedTo(ref(acc), Literal(Constant(accessors.size)))
+          Assign(ref(acc), ref(defn.staticsMethod("mix".toTermName)).appliedTo(ref(acc), hashImpl(accessor)))
+        val finish = ref(defn.staticsMethod("finalizeHash".toTermName)).appliedTo(ref(acc), Literal(Constant(accessors.size)))
         Block(accDef :: mixes, finish)
       } else {
         // Pre-compute the hash code
@@ -235,10 +235,10 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
         case tpnme.Boolean                         => If(ref(sym), Literal(Constant(1231)), Literal(Constant(1237)))
         case tpnme.Int                             => ref(sym)
         case tpnme.Short | tpnme.Byte | tpnme.Char => ref(sym).select(nme.toInt)
-        case tpnme.Long                            => ref(defn.staticsMethod("longHash")).appliedTo(ref(sym))
-        case tpnme.Double                          => ref(defn.staticsMethod("doubleHash")).appliedTo(ref(sym))
-        case tpnme.Float                           => ref(defn.staticsMethod("floatHash")).appliedTo(ref(sym))
-        case _                                     => ref(defn.staticsMethod("anyHash")).appliedTo(ref(sym))
+        case tpnme.Long                            => ref(defn.staticsMethod("longHash".toTermName)).appliedTo(ref(sym))
+        case tpnme.Double                          => ref(defn.staticsMethod("doubleHash".toTermName)).appliedTo(ref(sym))
+        case tpnme.Float                           => ref(defn.staticsMethod("floatHash".toTermName)).appliedTo(ref(sym))
+        case _                                     => ref(defn.staticsMethod("anyHash".toTermName)).appliedTo(ref(sym))
       }
 
     /** The class
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index 6be342739f75..f3c85cf8a111 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -102,7 +102,7 @@ class TreeChecker extends Phase with SymTransformer {
   def phaseName: String = "Ycheck"
 
   def run(implicit ctx: Context): Unit = {
-    check(ctx.allPhases, ctx)
+    check(ctx.base.allPhases, ctx)
   }
 
   private def previousPhases(phases: List[Phase])(implicit ctx: Context): List[Phase] = phases match {
@@ -119,7 +119,7 @@ class TreeChecker extends Phase with SymTransformer {
 
   def check(phasesToRun: Seq[Phase], ctx: Context) = {
     val prevPhase = ctx.phase.prev // can be a mini-phase
-    val squahsedPhase = ctx.squashed(prevPhase)
+    val squahsedPhase = ctx.base.squashed(prevPhase)
     ctx.echo(s"checking ${ctx.compilationUnit} after phase ${squahsedPhase}")
 
     assertSelectWrapsNew(ctx.compilationUnit.tpdTree)(ctx)
@@ -192,7 +192,7 @@ class TreeChecker extends Phase with SymTransformer {
     /** assert Java classes are not used as objects */
     def assertIdentNotJavaClass(tree: Tree)(implicit ctx: Context): Unit = tree match {
       case _ : untpd.Ident =>
-        assert(!tree.symbol.is(JavaModule), "Java class can't be used as value: " + tree)
+        assert(!tree.symbol.isBoth(JavaDefined, and = Module), "Java class can't be used as value: " + tree)
       case _ =>
     }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala b/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala
index 59be424e746c..e118cb9fc9d9 100644
--- a/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala
@@ -88,7 +88,7 @@ class TryCatchPatterns extends MiniPhase {
     else {
       val exName = ExceptionBinderName.fresh()
       val fallbackSelector =
-        ctx.newSymbol(ctx.owner, exName, Flags.Synthetic | Flags.Case, defn.ThrowableType, coord = pos)
+        ctx.newSymbol(ctx.owner, exName, Flags.Synthetic | Flags.Case, defn.ThrowableType, coord = pos.toCoord)
       val sel = Ident(fallbackSelector.termRef).withPos(pos)
       val rethrow = CaseDef(EmptyTree, EmptyTree, Throw(ref(fallbackSelector)))
       Some(CaseDef(
diff --git a/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala b/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala
index d474c77b4621..b7eb024b0f4d 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala
@@ -12,23 +12,20 @@ import NameOps._
 import language.implicitConversions
 
 object TypeUtils {
-  implicit def decorateTypeUtils(tpe: Type): TypeUtils = new TypeUtils(tpe)
-}
-
-/** A decorator that provides methods on types
- *  that are needed in the transformer pipeline.
- */
-class TypeUtils(val self: Type) extends AnyVal {
-  import TypeUtils._
+  /** A decorator that provides methods on types
+   *  that are needed in the transformer pipeline.
+   */
+  implicit class TypeUtilsOps(val self: Type) extends AnyVal {
 
-  def isErasedValueType(implicit ctx: Context): Boolean =
-    self.isInstanceOf[ErasedValueType]
+    def isErasedValueType(implicit ctx: Context): Boolean =
+      self.isInstanceOf[ErasedValueType]
 
-  def isPrimitiveValueType(implicit ctx: Context): Boolean =
-    self.classSymbol.isPrimitiveValueClass
+    def isPrimitiveValueType(implicit ctx: Context): Boolean =
+      self.classSymbol.isPrimitiveValueClass
 
-  def ensureMethodic(implicit ctx: Context): Type = self match {
-    case self: MethodicType => self
-    case _ => if (ctx.erasedTypes) MethodType(Nil, self) else ExprType(self)
+    def ensureMethodic(implicit ctx: Context): Type = self match {
+      case self: MethodicType => self
+      case _ => if (ctx.erasedTypes) MethodType(Nil, self) else ExprType(self)
+    }
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/ValueClasses.scala b/compiler/src/dotty/tools/dotc/transform/ValueClasses.scala
index 4642b34c5ced..f107da1b5070 100644
--- a/compiler/src/dotty/tools/dotc/transform/ValueClasses.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ValueClasses.scala
@@ -25,7 +25,7 @@ object ValueClasses {
     d.isRealMethod &&
       isDerivedValueClass(d.owner) &&
       !d.isConstructor &&
-      !d.isSuperAccessor &&
+      !d.symbol.isSuperAccessor &&
       !d.is(Macro)
 
   /** The member of a derived value class that unboxes it. */
diff --git a/compiler/src/dotty/tools/dotc/transform/localopt/DropNoEffects.scala b/compiler/src/dotty/tools/dotc/transform/localopt/DropNoEffects.scala
index f84ec732e25c..7e493531d3b6 100644
--- a/compiler/src/dotty/tools/dotc/transform/localopt/DropNoEffects.scala
+++ b/compiler/src/dotty/tools/dotc/transform/localopt/DropNoEffects.scala
@@ -101,7 +101,7 @@ class DropNoEffects(val simplifyPhase: Simplify) extends Optimisation {
 
     case t: Ident if !t.symbol.is(Method | Lazy) && !t.symbol.info.isInstanceOf[ExprType] || effectsDontEscape(t) =>
       val prefix = desugarIdentPrefix(t)
-      if (!prefix.isEmpty && !prefix.symbol.is(allOf(JavaDefined, Package))) t
+      if (!prefix.isEmpty && !prefix.symbol.isBoth(JavaDefined, and = Package)) t
       else EmptyTree
 
     case app: Apply if app.fun.symbol.is(Label) && !app.tpe.finalResultType.derivesFrom(defn.UnitClass) =>
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index da4f0feb2f8a..af892a5cd4ec 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -384,7 +384,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
     lazy val caseAccessors = caseClass.caseAccessors.filter(_.is(Method))
 
     def isSyntheticScala2Unapply(sym: Symbol) =
-      sym.is(SyntheticCase) && sym.owner.is(Scala2x)
+      sym.isBoth(Synthetic, and = Case) && sym.owner.is(Scala2x)
 
     val mt @ MethodType(_) = unapp.widen
 
@@ -576,7 +576,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
       case tp: RefinedType =>
         recur(tp.parent)
       case tp: TypeRef =>
-        recur(tp.prefix) && !(tp.classSymbol.is(AbstractFinal))
+        recur(tp.prefix) && !(tp.classSymbol.isBoth(Abstract, and = Final))
       case _ =>
         true
     }
@@ -708,7 +708,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
         canDecompose(and.tp1) || canDecompose(and.tp2)
       }) ||
       tp.isRef(defn.BooleanClass) ||
-      tp.classSymbol.is(allOf(Enum, Sealed))  // Enum value doesn't have Sealed flag
+      tp.classSymbol.isBoth(Enum, and = Sealed)  // Enum value doesn't have Sealed flag
 
     debug.println(s"decomposable: ${tp.show} = $res")
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index fc2d4eae6422..44a07b2378a1 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -950,7 +950,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
             fullyDefinedType(unapplyArgType, "pattern selector", tree.pos)
             selType
           } else if (isSubTypeOfParent(unapplyArgType, selType)(ctx.addMode(Mode.GADTflexible))) {
-            val patternBound = maximizeType(unapplyArgType, tree.pos, fromScala2x)
+            val patternBound = maximizeType(unapplyArgType, tree.coord, fromScala2x)
             if (patternBound.nonEmpty) unapplyFn = addBinders(unapplyFn, patternBound)
             unapp.println(i"case 2 $unapplyArgType ${ctx.typerState.constraint}")
             unapplyArgType
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
index 942628519545..03f3a44eabae 100644
--- a/compiler/src/dotty/tools/dotc/typer/Checking.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -339,7 +339,7 @@ object Checking {
       if (sym.is(flag))
         fail(AbstractMemberMayNotHaveModifier(sym, flag))
     def checkNoConflict(flag1: FlagSet, flag2: FlagSet) =
-      if (sym.is(allOf(flag1, flag2)))
+      if (sym.isBoth(flag1, flag2))
         fail(i"illegal combination of modifiers: `$flag1` and `$flag2` for: $sym")
     def checkApplicable(flag: FlagSet, ok: Boolean) =
       if (!ok && !sym.is(Synthetic))
@@ -532,7 +532,7 @@ trait Checking {
       val sym = tree.tpe.termSymbol
       // The check is avoided inside Java compilation units because it always fails
       // on the singleton type Module.type.
-      if ((sym is Package) || ((sym is JavaModule) && !ctx.compilationUnit.isJava)) ctx.error(JavaSymbolIsNotAValue(sym), tree.pos)
+      if (sym.is(Package) || sym.isBoth(JavaDefined, and = Module) && !ctx.compilationUnit.isJava) ctx.error(JavaSymbolIsNotAValue(sym), tree.pos)
     }
     tree
   }
@@ -602,7 +602,7 @@ trait Checking {
   /** Check that `tree` is a pure expression of constant type */
   def checkInlineConformant(tree: Tree, what: => String)(implicit ctx: Context): Unit =
     tree.tpe match {
-      case tp: TermRef if tp.symbol.is(InlineParam) => // ok
+      case tp: TermRef if tp.symbol.isBoth(Inline, and = Param) => // ok
       case tp => tp.widenTermRefExpr match {
         case tp: ConstantType if isPureExpr(tree) => // ok
         case tp if defn.isFunctionType(tp) && isPureExpr(tree) => // ok
@@ -772,7 +772,6 @@ trait Checking {
 
   /** Check that all case classes that extend `scala.Enum` are `enum` cases */
   def checkEnum(cdef: untpd.TypeDef, cls: Symbol)(implicit ctx: Context): Unit = {
-    import untpd.modsDeco
     def isEnumAnonCls =
       cls.isAnonymousClass &&
       cls.owner.isTerm &&
diff --git a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
index 2f39b07aa998..f379a85d5d73 100644
--- a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
+++ b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
@@ -48,7 +48,7 @@ abstract class Lifter {
       val name = UniqueName.fresh(prefix)
       var liftedType = fullyDefinedType(expr.tpe.widen, "lifted expression", expr.pos)
       if (liftedFlags.is(Method)) liftedType = ExprType(liftedType)
-      val lifted = ctx.newSymbol(ctx.owner, name, liftedFlags, liftedType, coord = positionCoord(expr.pos))
+      val lifted = ctx.newSymbol(ctx.owner, name, liftedFlags, liftedType, coord = expr.coord)
       defs += liftedDef(lifted, expr).withPos(expr.pos.focus)
       ref(lifted.termRef).withPos(expr.pos)
     }
diff --git a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
index bc90ec7df8ae..9ec4409eb049 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
@@ -231,7 +231,7 @@ object Inferencing {
    *  @return   The list of type symbols that were created
    *            to instantiate undetermined type variables that occur non-variantly
    */
-  def maximizeType(tp: Type, pos: Position, fromScala2x: Boolean)(implicit ctx: Context): List[Symbol] = Stats.track("maximizeType") {
+  def maximizeType(tp: Type, coord: Coord, fromScala2x: Boolean)(implicit ctx: Context): List[Symbol] = Stats.track("maximizeType") {
     val vs = variances(tp)
     val patternBound = new mutable.ListBuffer[Symbol]
     vs foreachBinding { (tvar, v) =>
@@ -242,7 +242,7 @@ object Inferencing {
         if (bounds.hi <:< bounds.lo || bounds.hi.classSymbol.is(Final) || fromScala2x)
           tvar.instantiate(fromBelow = false)
         else {
-          val wildCard = ctx.newPatternBoundSymbol(UniqueName.fresh(tvar.origin.paramName), bounds, pos)
+          val wildCard = ctx.newPatternBoundSymbol(UniqueName.fresh(tvar.origin.paramName), bounds, coord)
           tvar.instantiateWith(wildCard.typeRef)
           patternBound += wildCard
         }
diff --git a/compiler/src/dotty/tools/dotc/typer/Inliner.scala b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
index 49a507e0994c..56b40e495ec3 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
@@ -70,7 +70,7 @@ object Inliner {
           name = if (tree.isTerm) accessorName.toTermName else accessorName.toTypeName,
           flags = if (tree.isTerm) Synthetic | Method else Synthetic,
           info = accessorInfo,
-          coord = tree.pos).entered
+          coord = tree.coord).entered
 
       /** Add an accessor to a non-public method and replace the original access with a
        *  call to the accessor.
@@ -337,7 +337,7 @@ class Inliner(call: tpd.Tree, rhs: tpd.Tree)(implicit ctx: Context) {
   computeParamBindings(meth.info, targs, argss)
 
   private def newSym(name: Name, flags: FlagSet, info: Type): Symbol =
-    ctx.newSymbol(ctx.owner, name, flags, info, coord = call.pos)
+    ctx.newSymbol(ctx.owner, name, flags, info, coord = call.coord)
 
   /** Populate `paramBinding` and `bindingsBuf` by matching parameters with
    *  corresponding arguments. `bindingbuf` will be further extended later by
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 69836719c7d3..27f5bac22d0d 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -333,7 +333,7 @@ class Namer { typer: Typer =>
         val cls =
           createOrRefine[ClassSymbol](tree, name, flags,
             cls => adjustIfModule(new ClassCompleter(cls, tree)(ctx), tree),
-            ctx.newClassSymbol(ctx.owner, name, _, _, _, tree.namePos, ctx.source.file))
+            ctx.newClassSymbol(ctx.owner, name, _, _, _, tree.coord, ctx.source.file))
         cls.completer.asInstanceOf[ClassCompleter].init()
         cls
       case tree: MemberDef =>
@@ -365,9 +365,9 @@ class Namer { typer: Typer =>
         val info = adjustIfModule(completer, tree)
         createOrRefine[Symbol](tree, name, flags | deferred | method | higherKinded,
           _ => info,
-          (fs, _, pwithin) => ctx.newSymbol(ctx.owner, name, fs, info, pwithin, tree.namePos))
+          (fs, _, pwithin) => ctx.newSymbol(ctx.owner, name, fs, info, pwithin, tree.coord))
       case tree: Import =>
-        recordSym(ctx.newImportSymbol(ctx.owner, new Completer(tree), tree.pos), tree)
+        recordSym(ctx.newImportSymbol(ctx.owner, new Completer(tree), tree.coord), tree)
       case _ =>
         NoSymbol
     }
@@ -494,14 +494,14 @@ class Namer { typer: Typer =>
     // We don't check for clazz.superClass == JavaEnumClass, because this causes a illegal
     // cyclic reference error. See the commit message for details.
     //  if (ctx.compilationUnit.isJava) ctx.owner.companionClass.is(Enum) else ctx.owner.is(Enum)
-    vd.mods.is(allOf(Enum,  Stable, JavaStatic, JavaDefined)) // && ownerHasEnumFlag
+    vd.mods.isBoth(Enum, and = Stable) && vd.mods.isBoth(JavaStatic, JavaDefined) // && ownerHasEnumFlag
   }
 
   /** Add java enum constants */
   def addEnumConstants(mdef: DefTree, sym: Symbol)(implicit ctx: Context): Unit = mdef match {
     case vdef: ValDef if (isEnumConstant(vdef)) =>
       val enumClass = sym.owner.linkedClass
-      if (!(enumClass is Flags.Sealed)) enumClass.setFlag(Flags.AbstractSealed)
+      if (!(enumClass is Flags.Sealed)) enumClass.setFlag(Flags.Abstract | Flags.Sealed)
       enumClass.addAnnotation(Annotation.Child(sym))
     case _ =>
   }
@@ -745,7 +745,7 @@ class Namer { typer: Typer =>
       while (c.owner != target) c = c.outer
       c
     }
-    for (annotTree <- untpd.modsDeco(stat).mods.annotations) {
+    for (annotTree <- stat.mods.annotations) {
       val cls = typedAheadAnnotation(annotTree)(annotCtx)
       if (sym.unforcedAnnotation(cls).isEmpty) {
         val ann = Annotation.deferred(cls, implicit ctx => typedAnnotation(annotTree))
@@ -958,7 +958,7 @@ class Namer { typer: Typer =>
           val moduleType = cls.owner.thisType select sourceModule
           if (self.name == nme.WILDCARD) moduleType
           else recordSym(
-            ctx.newSymbol(cls, self.name, self.mods.flags, moduleType, coord = self.pos),
+            ctx.newSymbol(cls, self.name, self.mods.flags, moduleType, coord = self.coord),
             self)
         }
         else createSymbol(self)
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index 2a0bafe31a2d..e040f5c60856 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -321,7 +321,7 @@ object RefChecks {
         (member.flags & AccessFlags).isEmpty // member is public
         || // - or -
         (!other.is(Protected) || member.is(Protected)) && // if o is protected, so is m, and
-        (ob.isContainedIn(mb) || other.is(JavaProtected)) // m relaxes o's access boundary,
+        (ob.isContainedIn(mb) || other.isBoth(JavaDefined, and = Protected)) // m relaxes o's access boundary,
         // or o is Java defined and protected (see #3946)
         )
       if (!isOverrideAccessOK) {
@@ -341,7 +341,7 @@ object RefChecks {
         // the default getter: one default getter might sometimes override, sometimes not. Example in comment on ticket.
         // Also excluded under Scala2 mode are overrides of default methods of Java traits.
         if (autoOverride(member) ||
-            other.owner.is(JavaTrait) && ctx.testScala2Mode("`override' modifier required when a Java 8 default method is re-implemented", member.pos))
+            other.owner.isJavaTrait && ctx.testScala2Mode("`override' modifier required when a Java 8 default method is re-implemented", member.pos))
           member.setFlag(Override)
         else if (member.owner != clazz && other.owner != clazz && !(other.owner derivesFrom member.owner))
           emitOverrideError(
@@ -375,7 +375,7 @@ object RefChecks {
         overrideError("must be declared lazy to override a lazy value")
       } else if (member.is(Macro, butNot = Scala2x)) { // (1.9)
         overrideError("is a macro, may not override anything")
-      } else if (other.is(Deferred) && member.is(Scala2Macro) && member.extendedOverriddenSymbols.forall(_.is(Deferred))) { // (1.10)
+      } else if (other.is(Deferred) && member.isBoth(Macro, and = Scala2x) && member.extendedOverriddenSymbols.forall(_.is(Deferred))) { // (1.10)
         overrideError("cannot be used here - term macros cannot override abstract methods")
       } else if (other.is(Macro) && !member.is(Macro)) { // (1.11)
         overrideError("cannot be used here - only term macros can override term macros")
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 438b3ef9b279..a89206a1c466 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -795,7 +795,7 @@ class Typer extends Namer
     args match {
       case ValDef(_, _, _) :: _ =>
         typedDependent(args.asInstanceOf[List[ValDef]])(
-          ctx.fresh.setOwner(ctx.newRefinedClassSymbol(tree.pos)).setNewScope)
+          ctx.fresh.setOwner(ctx.newRefinedClassSymbol(tree.coord)).setNewScope)
       case _ =>
         typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funCls.typeRef), args :+ body), pt)
     }
@@ -1283,7 +1283,7 @@ class Typer extends Namer
       //val ptt = if (lo.isEmpty && hi.isEmpty) pt else
       if (ctx.isAfterTyper) tree1
       else {
-        val wildcardSym = ctx.newPatternBoundSymbol(tpnme.WILDCARD, tree1.tpe & pt, tree.pos)
+        val wildcardSym = ctx.newPatternBoundSymbol(tpnme.WILDCARD, tree1.tpe & pt, tree.coord)
         untpd.Bind(tpnme.WILDCARD, tree1).withType(wildcardSym.typeRef)
       }
     }
@@ -1304,7 +1304,7 @@ class Typer extends Namer
       case _ =>
         if (tree.name == nme.WILDCARD) body1
         else {
-          val sym = ctx.newPatternBoundSymbol(tree.name, body1.tpe.underlyingIfRepeated(isJava = false), tree.pos)
+          val sym = ctx.newPatternBoundSymbol(tree.name, body1.tpe.underlyingIfRepeated(isJava = false), tree.coord)
           if (ctx.mode.is(Mode.InPatternAlternative))
             ctx.error(i"Illegal variable ${sym.name} in pattern alternative", tree.pos)
           assignType(cpy.Bind(tree)(tree.name, body1), sym)
@@ -1333,7 +1333,7 @@ class Typer extends Namer
       }
     }
     // necessary in order to mark the typed ahead annotations as definitely typed:
-    untpd.modsDeco(mdef).mods.annotations.foreach(typedAnnotation(_)(annotCtx))
+    mdef.mods.annotations.foreach(typedAnnotation(_)(annotCtx))
   }
 
   def typedAnnotation(annot: untpd.Tree)(implicit ctx: Context): Tree = track("typedAnnotation") {
@@ -1590,7 +1590,7 @@ class Typer extends Namer
   def checkVariance(tree: Tree)(implicit ctx: Context) = VarianceChecker.check(tree)
 
   def localDummy(cls: ClassSymbol, impl: untpd.Template)(implicit ctx: Context): Symbol =
-    ctx.newLocalDummy(cls, impl.pos)
+    ctx.newLocalDummy(cls, impl.coord)
 
   def typedImport(imp: untpd.Import, sym: Symbol)(implicit ctx: Context): Import = track("typedImport") {
     val expr1 = typedExpr(imp.expr, AnySelectionProto)
@@ -1861,7 +1861,6 @@ class Typer extends Namer
               case mdef1: DefDef if Inliner.hasBodyToInline(mdef1.symbol) =>
                 buf ++= inlineExpansion(mdef1)
               case mdef1 =>
-                import untpd.modsDeco
                 mdef match {
                   case mdef: untpd.TypeDef if mdef.mods.hasMod[untpd.Mod.Enum] =>
                     enumContexts(mdef1.symbol) = ctx
diff --git a/compiler/src/dotty/tools/dotc/util/Positions.scala b/compiler/src/dotty/tools/dotc/util/Positions.scala
index e9302df7d3f8..3bffefd3e955 100644
--- a/compiler/src/dotty/tools/dotc/util/Positions.scala
+++ b/compiler/src/dotty/tools/dotc/util/Positions.scala
@@ -123,6 +123,10 @@ object Positions {
       else
         s"${left}no position${right}"
     }
+
+    def toCoord: Coord =
+      if (exists) new Coord(-(point + 1))
+      else NoCoord
   }
 
   private def fromOffsets(start: Int, end: Int, pointDelta: Int) = {
@@ -166,8 +170,9 @@ object Positions {
   }
 
   /** An index coordinate */
-  implicit def indexCoord(n: Int): Coord = new Coord(n + 1)
-  implicit def positionCoord(pos: Position): Coord =
+  def indexCoord(n: Int): Coord = new Coord(n + 1)
+
+  def pos2coord(pos: Position): Coord =
     if (pos.exists) new Coord(-(pos.point + 1))
     else NoCoord
 
diff --git a/compiler/src/dotty/tools/io/Jar.scala b/compiler/src/dotty/tools/io/Jar.scala
index 64bcef22027b..77a82ce39483 100644
--- a/compiler/src/dotty/tools/io/Jar.scala
+++ b/compiler/src/dotty/tools/io/Jar.scala
@@ -40,7 +40,7 @@ class Jar(file: File) extends Iterable[JarEntry] {
 
   protected def errorFn(msg: String): Unit = Console println msg
 
-  private implicit def enrichManifest(m: JManifest): Jar.WManifest = Jar.WManifest(m)
+  import Jar._
 
   lazy val jarFile  = new JarFile(file.jpath.toFile)
   lazy val manifest = withJarInput(s => Option(s.getManifest))
@@ -60,7 +60,7 @@ class Jar(file: File) extends Iterable[JarEntry] {
     finally in.close()
   }
   def jarWriter(mainAttrs: (Attributes.Name, String)*) = {
-    new JarWriter(file, Jar.WManifest(mainAttrs: _*).underlying)
+    new JarWriter(file, Jar.WManifest.apply(mainAttrs: _*).underlying)
   }
 
   override def foreach[U](f: JarEntry => U): Unit = withJarInput { in =>
@@ -132,10 +132,8 @@ object Jar {
 
       m
     }
-    def apply(manifest: JManifest): WManifest = new WManifest(manifest)
-    implicit def unenrichManifest(x: WManifest): JManifest = x.underlying
   }
-  class WManifest(manifest: JManifest) {
+  implicit class WManifest(val manifest: JManifest) {
     for ((k, v) <- initialMainAttrs)
       this(k) = v
 
diff --git a/compiler/src/dotty/tools/repl/AmmoniteReader.scala b/compiler/src/dotty/tools/repl/AmmoniteReader.scala
index ffbc7e61d100..10a71a4de9b2 100644
--- a/compiler/src/dotty/tools/repl/AmmoniteReader.scala
+++ b/compiler/src/dotty/tools/repl/AmmoniteReader.scala
@@ -122,7 +122,7 @@ private[repl] class AmmoniteReader(out: OutputStream,
     val prompt = Console.BLUE + "scala> " + Console.RESET
 
     Terminal
-      .readLine(prompt, reader, writer, allFilters, displayTransform)
+      .readLine(Prompt.fromString(prompt), reader, writer, allFilters, displayTransform)
       .map {
         case Result(source) => ParseResult(source)
         case Interrupt => SigKill
diff --git a/compiler/src/dotty/tools/repl/terminal/Ansi.scala b/compiler/src/dotty/tools/repl/terminal/Ansi.scala
index 207d4a6c88a1..5bf27e7c5b25 100644
--- a/compiler/src/dotty/tools/repl/terminal/Ansi.scala
+++ b/compiler/src/dotty/tools/repl/terminal/Ansi.scala
@@ -112,7 +112,7 @@ object Ansi {
   object Str {
     @sharable lazy val ansiRegex = "\u001B\\[[;\\d]*m".r
 
-    implicit def parse(raw: CharSequence): Str = {
+    def parse(raw: CharSequence): Str = {
       val chars        = new Array[Char](raw.length)
       val colors       = new Array[Short](raw.length)
       var currentIndex = 0
diff --git a/compiler/src/dotty/tools/repl/terminal/Protocol.scala b/compiler/src/dotty/tools/repl/terminal/Protocol.scala
index 800b745e47c5..996833d20218 100644
--- a/compiler/src/dotty/tools/repl/terminal/Protocol.scala
+++ b/compiler/src/dotty/tools/repl/terminal/Protocol.scala
@@ -10,7 +10,7 @@ case class TermState(
   inputs: LazyList[Int],
   buffer: Vector[Char],
   cursor: Int,
-  msg: Ansi.Str = ""
+  msg: Ansi.Str = Ansi.Str.parse("")
 ) extends TermAction
 
 object TermState {
diff --git a/compiler/src/dotty/tools/repl/terminal/Terminal.scala b/compiler/src/dotty/tools/repl/terminal/Terminal.scala
index dd3da9a87929..48db1319b165 100644
--- a/compiler/src/dotty/tools/repl/terminal/Terminal.scala
+++ b/compiler/src/dotty/tools/repl/terminal/Terminal.scala
@@ -301,7 +301,7 @@ object Terminal {
     lazy val ansi = new AnsiNav(writer)
     lazy val (width, _, initialConfig) = TTY.init()
     try {
-      readChar(TermState(LazyList.continually(reader.read()), Vector.empty, 0, ""), 0)
+      readChar(TermState(LazyList.continually(reader.read()), Vector.empty, 0, Ansi.Str.parse("")), 0)
     }
     finally {
 
@@ -315,7 +315,7 @@ object Terminal {
   }
 }
 object Prompt {
-  implicit def construct(prompt: String): Prompt = {
+  def fromString(prompt: String): Prompt = {
     val parsedPrompt = Ansi.Str.parse(prompt)
     val index = parsedPrompt.plainText.lastIndexOf('\n')
     val (_, last) = parsedPrompt.splitAt(index+1)
diff --git a/compiler/src/dotty/tools/repl/terminal/Utils.scala b/compiler/src/dotty/tools/repl/terminal/Utils.scala
index e7b5dcddbe0e..bc36a6e058db 100644
--- a/compiler/src/dotty/tools/repl/terminal/Utils.scala
+++ b/compiler/src/dotty/tools/repl/terminal/Utils.scala
@@ -202,7 +202,7 @@ object FrontEndUtils {
     transpose(grouped).iterator.flatMap { group =>
       val last = group.last
       group.init.map(
-        x => x ++ " " * (width / columns - x.length)
+        x => x ++ Ansi.Str.parse(" " * (width / columns - x.length))
       ) :+ last :+ Ansi.Str.parse(newLine)
     }
     .map(_.render)
diff --git a/compiler/src/dotty/tools/repl/terminal/filters/HistoryFilter.scala b/compiler/src/dotty/tools/repl/terminal/filters/HistoryFilter.scala
index 992c70774926..0e2fd689d68d 100644
--- a/compiler/src/dotty/tools/repl/terminal/filters/HistoryFilter.scala
+++ b/compiler/src/dotty/tools/repl/terminal/filters/HistoryFilter.scala
@@ -106,7 +106,7 @@ class HistoryFilter(
     searchHistory(historyIndex - 1, -1, b, b)
 
   def wrap(rest: LazyList[Int], out: (Vector[Char], Int, String)) =
-    TS(rest, out._1, out._2, out._3)
+    TS(rest, out._1, out._2, Ansi.Str.parse(out._3))
 
   def ctrlR(b: Vector[Char], c: Int) =
     if (activeSearch) up(b, c)
diff --git a/compiler/src/dotty/tools/repl/terminal/filters/UndoFilter.scala b/compiler/src/dotty/tools/repl/terminal/filters/UndoFilter.scala
index c0b01ea1b7f5..716fd951a8c8 100644
--- a/compiler/src/dotty/tools/repl/terminal/filters/UndoFilter.scala
+++ b/compiler/src/dotty/tools/repl/terminal/filters/UndoFilter.scala
@@ -40,7 +40,7 @@ case class UndoFilter(maxUndo: Int = 25) extends DelegateFilter("UndoFilter") {
   var undoIndex = 0
   /**
     * An enum representing what the user is "currently" doing. Used to
-    * collapse sequential actions into one undo step: e.g. 10 plai 
+    * collapse sequential actions into one undo step: e.g. 10 plai
     * chars typed becomes 1 undo step, or 10 chars deleted becomes one undo
     * step, but 4 chars typed followed by 3 chars deleted followed by 3 chars
     * typed gets grouped into 3 different undo steps
@@ -147,8 +147,8 @@ object UndoState {
 }
 
 object UndoFilter {
-  val undoMsg       = Ansi.Color.Blue(" ...undoing last action, `Alt -` or `Esc -` to redo")
-  val cannotUndoMsg = Ansi.Color.Blue(" ...no more actions to undo")
-  val redoMsg       = Ansi.Color.Blue(" ...redoing last action")
-  val cannotRedoMsg = Ansi.Color.Blue(" ...no more actions to redo")
+  val undoMsg       = Ansi.Color.Blue(Ansi.Str.parse(" ...undoing last action, `Alt -` or `Esc -` to redo"))
+  val cannotUndoMsg = Ansi.Color.Blue(Ansi.Str.parse(" ...no more actions to undo"))
+  val redoMsg       = Ansi.Color.Blue(Ansi.Str.parse(" ...redoing last action"))
+  val cannotRedoMsg = Ansi.Color.Blue(Ansi.Str.parse(" ...no more actions to redo"))
 }
diff --git a/compiler/test/dotty/tools/dotc/parsing/ModifiersParsingTest.scala b/compiler/test/dotty/tools/dotc/parsing/ModifiersParsingTest.scala
index 6627fbcddd93..221019594dd0 100644
--- a/compiler/test/dotty/tools/dotc/parsing/ModifiersParsingTest.scala
+++ b/compiler/test/dotty/tools/dotc/parsing/ModifiersParsingTest.scala
@@ -5,7 +5,6 @@ package parsing
 import org.junit.Test
 import org.junit.Assert._
 
-import ast.untpd.modsDeco
 import ast.untpd._
 import ast.{ Trees => d }
 import Parsers.Parser
@@ -16,7 +15,7 @@ import core.Flags
 object ModifiersParsingTest {
   implicit val ctx: Context = (new ContextBase).initialCtx
 
-  implicit def parse(code: String): Tree = {
+  def parse(code: String): Tree = {
     val (_, stats) = new Parser(new SourceFile("<meta>", code.toCharArray)).templateStatSeq()
     stats match { case List(stat) => stat; case stats => Thicket(stats) }
   }
@@ -78,42 +77,42 @@ class ModifiersParsingTest {
 
 
   @Test def valDef = {
-    var source: Tree = "class A(var a: Int)"
+    var source = parse("class A(var a: Int)")
     assert(source.firstConstrValDef.modifiers == List(Mod.Var()))
 
-    source = "class A(val a: Int)"
+    source = parse("class A(val a: Int)")
     assert(source.firstConstrValDef.modifiers == List(Mod.Val()))
 
-    source = "class A(private val a: Int)"
+    source = parse("class A(private val a: Int)")
     assert(source.firstConstrValDef.modifiers == List(Mod.Private(), Mod.Val()))
 
-    source = "class A(protected var a: Int)"
+    source = parse("class A(protected var a: Int)")
     assert(source.firstConstrValDef.modifiers == List(Mod.Protected(), Mod.Var()))
 
-    source = "class A(protected implicit val a: Int)"
+    source = parse("class A(protected implicit val a: Int)")
     assert(source.firstConstrValDef.modifiers == List(Mod.Protected(), Mod.Implicit(), Mod.Val()))
 
-    source = "class A[T]"
+    source = parse("class A[T]")
     assert(source.firstTypeParam.modifiers == List())
   }
 
   @Test def typeDef = {
-    var source: Tree = "class A"
+    var source = parse("class A")
     assert(source.modifiers == List())
 
-    source = "sealed class A"
+    source = parse("sealed class A")
     assert(source.modifiers == List(Mod.Sealed()))
 
-    source = "implicit class A"
+    source = parse("implicit class A")
     assert(source.modifiers == List(Mod.Implicit()))
 
-    source = "abstract sealed class A"
+    source = parse("abstract sealed class A")
     assert(source.modifiers == List(Mod.Abstract(), Mod.Sealed()))
   }
 
   @Test def fieldDef = {
-    val source: Tree =
-      """
+    val source =
+      parse("""
         | class A {
         |   lazy var a = ???
         |   lazy private val b = ???
@@ -122,7 +121,7 @@ class ModifiersParsingTest {
         |   abstract override def f: Boolean
         |   inline def g(n: Int) = ???
         | }
-      """.stripMargin
+      """.stripMargin)
 
     assert(source.field("a").modifiers == List(Mod.Lazy(), Mod.Var()))
     assert(source.field("b").modifiers == List(Mod.Lazy(), Mod.Private(), Mod.Val()))
@@ -132,29 +131,29 @@ class ModifiersParsingTest {
   }
 
   @Test def paramDef = {
-    var source: Tree = "def f(inline a: Int) = ???"
+    var source = parse("def f(inline a: Int) = ???")
     assert(source.defParam(0).modifiers == List(Mod.Inline()))
 
-    source = "def f(implicit a: Int, b: Int) = ???"
+    source = parse("def f(implicit a: Int, b: Int) = ???")
     assert(source.defParam(0).modifiers == List(Mod.Implicit()))
     assert(source.defParam(1).modifiers == List(Mod.Implicit()))
 
-    source = "def f(x: Int, y: Int)(implicit a: Int, b: Int) = ???"
+    source = parse("def f(x: Int, y: Int)(implicit a: Int, b: Int) = ???")
     assert(source.defParam(0, 0).modifiers == List())
     assert(source.defParam(1, 0).modifiers == List(Mod.Implicit()))
   }
 
   @Test def blockDef = {
-    var source: Tree = "implicit val x : A = ???"
+    var source = parse("implicit val x : A = ???")
     assert(source.modifiers == List(Mod.Implicit(), Mod.Val()))
 
-    source = "implicit var x : A = ???"
+    source = parse("implicit var x : A = ???")
     assert(source.modifiers == List(Mod.Implicit(), Mod.Var()))
 
-    source = "{ implicit var x : A = ??? }"
+    source = parse("{ implicit var x : A = ??? }")
     assert(source.stat(0).modifiers == List(Mod.Implicit(), Mod.Var()))
 
-    source = "{ implicit x => x * x }"
+    source = parse("{ implicit x => x * x }")
     assert(source.stat(0).funParam(0).modifiers == List(Mod.Implicit()))
   }
 }
diff --git a/compiler/test/dotty/tools/dotc/transform/TreeTransformerTest.scala b/compiler/test/dotty/tools/dotc/transform/TreeTransformerTest.scala
index aace7b734d17..1bb558e64806 100644
--- a/compiler/test/dotty/tools/dotc/transform/TreeTransformerTest.scala
+++ b/compiler/test/dotty/tools/dotc/transform/TreeTransformerTest.scala
@@ -16,7 +16,7 @@ class TreeTransformerTest extends DottyTest {
       implicit val ctx = context
       class EmptyTransform extends MiniPhase {
         override def phaseName: String = "empty"
-        init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
+        init(ctx.base, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
       val transformer = new MegaPhase(Array(new EmptyTransform))
       val transformed = transformer.transformUnit(tree)
@@ -34,7 +34,7 @@ class TreeTransformerTest extends DottyTest {
 
         override def transformLiteral(tree: tpd.Literal)(implicit ctx: Context): tpd.Tree = tpd.Literal(Constant(2))
         override def phaseName: String = "canReplaceConstant"
-        init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
+        init(ctx.base, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
       val transformer = new MegaPhase(Array(new ConstantTransform))
       val transformed = transformer.transformUnit(tree)
@@ -60,7 +60,7 @@ class TreeTransformerTest extends DottyTest {
           tpd.cpy.ValDef(tree)(rhs = tpd.Literal(Constant(2)))
         }
 
-        init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
+        init(ctx.base, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
       val transformer = new MegaPhase(Array(new Transformation))
       val tr = transformer.transformUnit(tree).toString
@@ -91,7 +91,7 @@ class TreeTransformerTest extends DottyTest {
           tpd.cpy.ValDef(tree)(rhs = tpd.Literal(Constant(2)))
         }
 
-        init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
+        init(ctx.base, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
       class Transformation2 extends MiniPhase {
         override def phaseName: String = "transformationOrder2"
@@ -102,7 +102,7 @@ class TreeTransformerTest extends DottyTest {
           tpd.cpy.ValDef(tree)(rhs = tpd.Literal(Constant(3)))
         }
 
-        init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
+        init(ctx.base, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
       val transformer = new MegaPhase(Array(new Transformation1, new Transformation2))
       val tr = transformer.transformUnit(tree).toString
@@ -135,7 +135,7 @@ class TreeTransformerTest extends DottyTest {
           tpd.cpy.ValDef(tree)(rhs = transformFollowing(tpd.Literal(Constant(2))))
         }
 
-        init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
+        init(ctx.base, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
       var transformed2 = 0
       class Transformation2 extends MiniPhase {
@@ -166,7 +166,7 @@ class TreeTransformerTest extends DottyTest {
           transformFollowing(tpd.cpy.ValDef(tree)(rhs = tpd.Literal(Constant(3))))
         }
 
-        init(ctx, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
+        init(ctx.base, ctx.period.firstPhaseId, ctx.period.lastPhaseId)
       }
       val transformer = new MegaPhase(Array(new Transformation1, new Transformation2))
       val tr = transformer.transformUnit(tree).toString
diff --git a/compiler/test/dotty/tools/repl/ReplCompilerTests.scala b/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
index d44da3201f9e..f45ffe08ab34 100644
--- a/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
+++ b/compiler/test/dotty/tools/repl/ReplCompilerTests.scala
@@ -14,23 +14,23 @@ import ReplTest._
 class ReplCompilerTests extends ReplTest {
 
   @Test def compileSingle: Unit = fromInitialState { implicit state =>
-    compiler.compile("def foo: 1 = 1").stateOrFail
+    compiler.compile("def foo: 1 = 1".toParsed).stateOrFail
   }
 
 
   @Test def compileTwo =
     fromInitialState { implicit state =>
-      compiler.compile("def foo: 1 = 1").stateOrFail
+      compiler.compile("def foo: 1 = 1".toParsed).stateOrFail
     }
     .andThen { implicit state =>
-      val s2 = compiler.compile("def foo(i: Int): i.type = i").stateOrFail
+      val s2 = compiler.compile("def foo(i: Int): i.type = i".toParsed).stateOrFail
       assert(s2.objectIndex == 2,
              s"Wrong object offset: expected 2 got ${s2.objectIndex}")
     }
 
   @Test def inspectSingle =
     fromInitialState { implicit state =>
-      val untpdTree = compiler.compile("def foo: 1 = 1").map(_._1.untpdTree)
+      val untpdTree = compiler.compile("def foo: 1 = 1".toParsed).map(_._1.untpdTree)
 
       untpdTree.fold(
         onErrors,
@@ -44,7 +44,7 @@ class ReplCompilerTests extends ReplTest {
     }
 
   @Test def testVar = fromInitialState { implicit state =>
-    compile("var x = 5")
+    compile("var x = 5".toParsed)
     assertEquals("var x: Int = 5\n", storedOutput())
   }
 
@@ -54,7 +54,7 @@ class ReplCompilerTests extends ReplTest {
          |val x = 5 + 5
          |1 + 1
          |var y = 5
-         |10 + 10""".stripMargin
+         |10 + 10""".stripMargin.toParsed
     }
 
     val expected = Set("def foo: Int",
@@ -68,12 +68,12 @@ class ReplCompilerTests extends ReplTest {
 
   @Test def testImportMutable =
     fromInitialState { implicit state =>
-      compile("import scala.collection.mutable")
+      compile("import scala.collection.mutable".toParsed)
     }
     .andThen { implicit state =>
       assert(state.imports.nonEmpty, "Didn't add import to `State` after compilation")
 
-      compile("""mutable.Map("one" -> 1)""")
+      compile("""mutable.Map("one" -> 1)""".toParsed)
 
       assertEquals(
         "val res0: scala.collection.mutable.Map[String, Int] = Map(one -> 1)\n",
@@ -82,9 +82,9 @@ class ReplCompilerTests extends ReplTest {
     }
 
   @Test def rebindVariable =
-    fromInitialState { implicit s => compile("var x = 5") }
+    fromInitialState { implicit s => compile("var x = 5".toParsed) }
     .andThen { implicit s =>
-      compile("x = 10")
+      compile("x = 10".toParsed)
       assertEquals(
         """|var x: Int = 5
            |x: Int = 10
@@ -96,28 +96,28 @@ class ReplCompilerTests extends ReplTest {
   // FIXME: Tests are not run in isolation, the classloader is corrupted after the first exception
   @Ignore def i3305: Unit = {
     fromInitialState { implicit s =>
-      compile("null.toString")
+      compile("null.toString".toParsed)
       assertTrue(storedOutput().startsWith("java.lang.NullPointerException"))
     }
 
     fromInitialState { implicit s =>
-      compile("def foo: Int = 1 + foo; foo")
+      compile("def foo: Int = 1 + foo; foo".toParsed)
       assertTrue(storedOutput().startsWith("def foo: Int\njava.lang.StackOverflowError"))
     }
 
     fromInitialState { implicit s =>
-      compile("""throw new IllegalArgumentException("Hello")""")
+      compile("""throw new IllegalArgumentException("Hello")""".toParsed)
       assertTrue(storedOutput().startsWith("java.lang.IllegalArgumentException: Hello"))
     }
 
     fromInitialState { implicit s =>
-      compile("val (x, y) = null")
+      compile("val (x, y) = null".toParsed)
       assertTrue(storedOutput().startsWith("scala.MatchError: null"))
     }
   }
 
   @Test def i2789: Unit = fromInitialState { implicit state =>
-    compile("(x: Int) => println(x)")
+    compile("(x: Int) => println(x)".toParsed)
     assertTrue(storedOutput().startsWith("val res0: Int => Unit ="))
   }
 }
diff --git a/compiler/test/dotty/tools/repl/ReplTest.scala b/compiler/test/dotty/tools/repl/ReplTest.scala
index 6d3679f9c4b7..eb05f1b68432 100644
--- a/compiler/test/dotty/tools/repl/ReplTest.scala
+++ b/compiler/test/dotty/tools/repl/ReplTest.scala
@@ -44,12 +44,14 @@ class ReplTest extends ReplDriver(
   def storedOutput(): String =
     stripColor(out.asInstanceOf[StoringPrintStream].flushStored())
 
-  protected implicit def toParsed(expr: String)(implicit state: State): Parsed = {
-    implicit val ctx = state.run.runContext
-    ParseResult(expr) match {
-      case pr: Parsed => pr
-      case pr =>
-        throw new java.lang.AssertionError(s"Expected parsed, got: $pr")
+  implicit class StringToParsed(expr: String) {
+    def toParsed(implicit state: State): Parsed = {
+      implicit val ctx = state.run.runContext
+      ParseResult(expr) match {
+        case pr: Parsed => pr
+        case pr =>
+          throw new java.lang.AssertionError(s"Expected parsed, got: $pr")
+      }
     }
   }
 
diff --git a/compiler/test/dotty/tools/repl/TypeTests.scala b/compiler/test/dotty/tools/repl/TypeTests.scala
index e751eb362afa..50fbf8cee366 100644
--- a/compiler/test/dotty/tools/repl/TypeTests.scala
+++ b/compiler/test/dotty/tools/repl/TypeTests.scala
@@ -18,7 +18,7 @@ class TypeTests extends ReplTest {
   }
 
   @Test def typeOfX =
-    fromInitialState { implicit s => compile("val x = 5") }
+    fromInitialState { implicit s => compile("val x = 5".toParsed) }
     .andThen { implicit s =>
       compiler.typeOf("x")
               .fold(onErrors, assertEquals("Int", _))
diff --git a/doc-tool/src/dotty/tools/dottydoc/core/ContextDottydoc.scala b/doc-tool/src/dotty/tools/dottydoc/core/ContextDottydoc.scala
index 4e62b2d58dfd..0e8c70a471ac 100644
--- a/doc-tool/src/dotty/tools/dottydoc/core/ContextDottydoc.scala
+++ b/doc-tool/src/dotty/tools/dottydoc/core/ContextDottydoc.scala
@@ -9,9 +9,10 @@ import dotc.core.Comments.ContextDocstrings
 import model.{ Package, Entity }
 import model.comment.Comment
 
+import dotty.tools.dotc.util.{Positions, SourcePosition, NoSourcePosition}
+import Positions.{Position, NoPosition}
 import dotc.core.Contexts.Context
 import dotc.printing.Highlighting._
-import dotc.util.{ SourcePosition, NoSourcePosition }
 
 class ContextDottydoc extends ContextDocstrings {
   import scala.collection.mutable
@@ -34,11 +35,11 @@ class ContextDottydoc extends ContextDocstrings {
     s -> _defs.get(s).map(xs => xs + d).getOrElse(Set(d))
   })
 
-  def error(msg: String, pos: SourcePosition)(implicit ctx: Context): Unit = ctx.error({
+  def error(msg: String, pos: Position)(implicit ctx: Context): Unit = ctx.error({
     NoColor("[") + Red("doc error") + "] " + msg
   }.toString, pos)
 
-  def error(msg: String)(implicit ctx: Context): Unit = error(msg, NoSourcePosition)
+  def error(msg: String)(implicit ctx: Context): Unit = error(msg, NoPosition)
 
   def warn(msg: String, pos: SourcePosition)(implicit ctx: Context): Unit = ctx.warning({
     NoColor("[") + Yellow("doc warn") + "] " + msg
@@ -46,18 +47,18 @@ class ContextDottydoc extends ContextDocstrings {
 
   def warn(msg: String)(implicit ctx: Context): Unit = warn(msg, NoSourcePosition)
 
-  def echo(msg: String, pos: SourcePosition)(implicit ctx: Context): Unit = ctx.echo({
+  def echo(msg: String, pos: Position)(implicit ctx: Context): Unit = ctx.echo({
     "[doc info] " + msg
   }.toString, pos)
 
-  def echo(msg: String)(implicit ctx: Context): Unit = echo(msg, NoSourcePosition)
+  def echo(msg: String)(implicit ctx: Context): Unit = echo(msg, NoPosition)
 
-  def debug(msg: String, pos: SourcePosition)(implicit ctx: Context): Unit =
+  def debug(msg: String, pos: Position)(implicit ctx: Context): Unit =
     if (ctx.settings.Ydebug.value) ctx.inform({
       "[doc debug] " + msg
     }.toString, pos)
 
-  def debug(msg: String)(implicit ctx: Context): Unit = debug(msg, NoSourcePosition)
+  def debug(msg: String)(implicit ctx: Context): Unit = debug(msg, NoPosition)
 
   def printSummary()(implicit ctx: Context): Unit = {
     def colored(part: Int, total: Int) =