diff --git a/compiler/sjs/backend/sjs/JSCodeGen.scala b/compiler/sjs/backend/sjs/JSCodeGen.scala
index 09f6d07b563e..1d6c538e6fdc 100644
--- a/compiler/sjs/backend/sjs/JSCodeGen.scala
+++ b/compiler/sjs/backend/sjs/JSCodeGen.scala
@@ -1704,7 +1704,7 @@ class JSCodeGen()(implicit ctx: Context) {
       nme.UNARY_! -> js.JSUnaryOp.!
     )
 
-    def unapply(name: Names.TermName): Option[js.JSUnaryOp.Code] =
+    def unapply(name: TermName): Option[js.JSUnaryOp.Code] =
       map.get(name)
   }
 
@@ -1732,7 +1732,7 @@ class JSCodeGen()(implicit ctx: Context) {
       nme.ZOR  -> js.JSBinaryOp.||
     )
 
-    def unapply(name: Names.TermName): Option[js.JSBinaryOp.Code] =
+    def unapply(name: TermName): Option[js.JSBinaryOp.Code] =
       map.get(name)
   }
 
diff --git a/compiler/sjs/backend/sjs/JSEncoding.scala b/compiler/sjs/backend/sjs/JSEncoding.scala
index e8ea3258bfa2..8644cdaf5760 100644
--- a/compiler/sjs/backend/sjs/JSEncoding.scala
+++ b/compiler/sjs/backend/sjs/JSEncoding.scala
@@ -39,11 +39,11 @@ object JSEncoding {
   private final val ScalaJSEnvironmentName = "ScalaJS"
 
   implicit class SymOps(val self: Symbol) extends AnyVal {
-    def unexpandedName(implicit ctx: Context): Names.Name =
+    def unexpandedName(implicit ctx: Context): Name =
       self.name.unexpandedName
   }
 
-  implicit class MyNameOps(val self: Names.Name) extends AnyVal {
+  implicit class MyNameOps(val self: Name) extends AnyVal {
     def decoded: String = self.decode.toString
   }
 
diff --git a/compiler/sjs/backend/sjs/JSPositions.scala b/compiler/sjs/backend/sjs/JSPositions.scala
index 10570da00129..019b87f32818 100644
--- a/compiler/sjs/backend/sjs/JSPositions.scala
+++ b/compiler/sjs/backend/sjs/JSPositions.scala
@@ -11,7 +11,7 @@ import org.scalajs.core.ir
 class JSPositions()(implicit ctx: Context) {
 
   /** Implicit conversion from dotty Position to ir.Position. */
-  implicit def pos2irPos(pos: Positions.Position): ir.Position = {
+  implicit def pos2irPos(pos: Position): ir.Position = {
     if (!pos.exists) ir.Position.NoPosition
     else {
       val source = pos2irPosCache.toIRSource(ctx.compilationUnit.source)
@@ -23,7 +23,7 @@ class JSPositions()(implicit ctx: Context) {
 
   /** Implicitly materializes an ir.Position from an implicit dotty Position. */
   implicit def implicitPos2irPos(
-      implicit pos: Positions.Position): ir.Position = {
+      implicit pos: Position): ir.Position = {
     pos2irPos(pos)
   }
 
diff --git a/compiler/src/dotty/tools/backend/jvm/CollectEntryPoints.scala b/compiler/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
index 8e7cfc688724..a2d178e70c49 100644
--- a/compiler/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
+++ b/compiler/src/dotty/tools/backend/jvm/CollectEntryPoints.scala
@@ -5,30 +5,15 @@ import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Types
 import dotty.tools.dotc.transform.MegaPhase._
 import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc
-import dotty.tools.dotc.core.Flags.FlagSet
-import dotty.tools.dotc.transform.Erasure
-import dotty.tools.dotc.transform.SymUtils._
-import java.io.{File => JFile}
+import java.io.{File => _}
 
-import scala.collection.generic.Clearable
-import scala.collection.mutable
-import scala.reflect.ClassTag
-import dotty.tools.io.{Directory, PlainDirectory, AbstractFile}
-import scala.tools.asm.{ClassVisitor, FieldVisitor, MethodVisitor}
-import scala.tools.nsc.backend.jvm.{BCodeHelpers, BackendInterface}
 import dotty.tools.dotc.core._
-import Periods._
 import SymDenotations._
 import Contexts._
 import Types._
 import Symbols._
-import Denotations._
-import Phases._
-import java.lang.AssertionError
 import dotty.tools.dotc.util.Positions.Position
 import Decorators._
-import tpd._
 import StdNames.nme
 
 /**
@@ -46,7 +31,7 @@ class CollectEntryPoints extends MiniPhase {
 }
 
 object CollectEntryPoints{
-  def isJavaMainMethod(sym: Symbol)(implicit ctx: Context) = {
+  def isJavaMainMethod(sym: Symbol)(implicit ctx: Context): Boolean = {
     (sym.name == nme.main) && (sym.info match {
       case r@MethodTpe(_, List(defn.ArrayOf(t)), _) =>
         (t.widenDealias =:= defn.StringType) && (
@@ -56,7 +41,6 @@ object CollectEntryPoints{
   }
 
   def isJavaEntryPoint(sym: Symbol)(implicit ctx: Context): Boolean = {
-    import Types.MethodType
     val d = ctx.definitions
     val StringType = d.StringType
     // The given class has a main method.
diff --git a/compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala b/compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala
index cabc51c394bf..8e646b5b7d81 100644
--- a/compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala
+++ b/compiler/src/dotty/tools/backend/jvm/CollectSuperCalls.scala
@@ -1,7 +1,6 @@
 package dotty.tools.backend.jvm
 
 import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.ast.Trees._
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Flags.Trait
diff --git a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
index 8114a00f80a9..d1b4f2d52f68 100644
--- a/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
+++ b/compiler/src/dotty/tools/backend/jvm/DottyBackendInterface.scala
@@ -6,37 +6,29 @@ import dotty.tools.dotc
 import dotty.tools.dotc.core.Flags.FlagSet
 import dotty.tools.dotc.transform.{Erasure, GenericSignatures}
 import dotty.tools.dotc.transform.SymUtils._
-import java.io.{File => JFile}
+import java.io.{File => _}
 
 import scala.collection.generic.Clearable
 import scala.collection.mutable
 import scala.reflect.ClassTag
 import scala.reflect.internal.util.WeakHashSet
-import dotty.tools.io.{AbstractFile, Directory, PlainDirectory}
-import scala.tools.asm.{AnnotationVisitor, ClassVisitor, FieldVisitor, MethodVisitor}
+import dotty.tools.io.AbstractFile
+import scala.tools.asm.AnnotationVisitor
 import scala.tools.nsc.backend.jvm.{BCodeHelpers, BackendInterface}
 import dotty.tools.dotc.core._
-import Periods._
-import SymDenotations._
 import Contexts._
 import Types._
 import Symbols._
-import Denotations._
 import Phases._
-import java.lang.AssertionError
 
-import dotty.tools.dotc.util.{DotClass, Positions}
+import dotty.tools.dotc.util.Positions
 import Decorators._
 import tpd._
 
 import scala.tools.asm
 import StdNames.{nme, str}
-import NameOps._
 import NameKinds.{DefaultGetterName, ExpandedName}
-import dotty.tools.dotc.core
-import dotty.tools.dotc.core.Names.TypeName
-
-import scala.annotation.tailrec
+import Names.TermName
 
 class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Map[Symbol, Set[ClassSymbol]])(implicit ctx: Context) extends BackendInterface{
   import Symbols.{toDenot, toClassDenot}
@@ -84,7 +76,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   type LabelDef        = tpd.DefDef
   type Closure         = tpd.Closure
 
-  val NoSymbol = Symbols.NoSymbol
+  val NoSymbol: Symbol = Symbols.NoSymbol
   val NoPosition: Position = Positions.NoPosition
   val EmptyTree: Tree = tpd.EmptyTree
 
@@ -112,11 +104,11 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   val nme_EQEQ_LOCAL_VAR: Name = StdNames.nme.EQEQ_LOCAL_VAR
 
    // require LambdaMetafactory: scalac uses getClassIfDefined, but we need those always.
-  override lazy val LambdaMetaFactory = ctx.requiredClass("java.lang.invoke.LambdaMetafactory")
-  override lazy val MethodHandle      = ctx.requiredClass("java.lang.invoke.MethodHandle")
+  override lazy val LambdaMetaFactory: ClassSymbol = ctx.requiredClass("java.lang.invoke.LambdaMetafactory")
+  override lazy val MethodHandle: ClassSymbol      = ctx.requiredClass("java.lang.invoke.MethodHandle")
 
   val nme_valueOf: Name = StdNames.nme.valueOf
-  val nme_apply = StdNames.nme.apply
+  val nme_apply: TermName = StdNames.nme.apply
   val NothingClass: Symbol = defn.NothingClass
   val NullClass: Symbol = defn.NullClass
   val ObjectClass: Symbol = defn.ObjectClass
@@ -136,7 +128,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   val LongClass: Symbol = defn.LongClass
   val FloatClass: Symbol = defn.FloatClass
   val DoubleClass: Symbol = defn.DoubleClass
-  def isArrayClone(tree: Tree) = tree match {
+  def isArrayClone(tree: Tree): Boolean = tree match {
     case Select(qual, StdNames.nme.clone_) if qual.tpe.widen.isInstanceOf[JavaArrayType] => true
     case _ => false
   }
@@ -154,11 +146,11 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   val String_valueOf: Symbol = defn.String_valueOf_Object
   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 JavaAnnotationClass = ctx.requiredClass("java.lang.annotation.Annotation")
+  lazy val AnnotationRetentionAttr: ClassSymbol = ctx.requiredClass("java.lang.annotation.Retention")
+  lazy val AnnotationRetentionSourceAttr: TermSymbol = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("SOURCE")
+  lazy val AnnotationRetentionClassAttr: TermSymbol = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("CLASS")
+  lazy val AnnotationRetentionRuntimeAttr: TermSymbol = ctx.requiredClass("java.lang.annotation.RetentionPolicy").linkedClass.requiredValue("RUNTIME")
+  lazy val JavaAnnotationClass: ClassSymbol = ctx.requiredClass("java.lang.annotation.Annotation")
 
   def boxMethods: Map[Symbol, Symbol] = defn.ScalaValueClasses().map{x => // @darkdimius Are you sure this should be a def?
     (x, Erasure.Boxing.boxMethod(x.asClass))
@@ -166,7 +158,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   def unboxMethods: Map[Symbol, Symbol] =
     defn.ScalaValueClasses().map(x => (x, Erasure.Boxing.unboxMethod(x.asClass))).toMap
 
-  override def isSyntheticArrayConstructor(s: Symbol) = {
+  override def isSyntheticArrayConstructor(s: Symbol): Boolean = {
     s eq defn.newArrayMethod
   }
 
@@ -317,7 +309,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   }
 
   override def emitAnnotations(cw: asm.ClassVisitor, annotations: List[Annotation], bcodeStore: BCodeHelpers)
-                              (innerClasesStore: bcodeStore.BCInnerClassGen) = {
+                              (innerClasesStore: bcodeStore.BCInnerClassGen): Unit = {
     for(annot <- annotations; if shouldEmitAnnotation(annot)) {
       val typ = annot.atp
       val assocs = annot.assocs
@@ -334,7 +326,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   }
 
   override def emitAnnotations(mw: asm.MethodVisitor, annotations: List[Annotation], bcodeStore: BCodeHelpers)
-                              (innerClasesStore: bcodeStore.BCInnerClassGen) = {
+                              (innerClasesStore: bcodeStore.BCInnerClassGen): Unit = {
     for(annot <- annotations; if shouldEmitAnnotation(annot)) {
       val typ = annot.atp
       val assocs = annot.assocs
@@ -344,7 +336,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   }
 
   override def emitAnnotations(fw: asm.FieldVisitor, annotations: List[Annotation], bcodeStore: BCodeHelpers)
-                              (innerClasesStore: bcodeStore.BCInnerClassGen) = {
+                              (innerClasesStore: bcodeStore.BCInnerClassGen): Unit = {
     for(annot <- annotations; if shouldEmitAnnotation(annot)) {
       val typ = annot.atp
       val assocs = annot.assocs
@@ -400,7 +392,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
   def emitAsmp: Option[String] = None
 
-  def shouldEmitJumpAfterLabels = true
+  def shouldEmitJumpAfterLabels: Boolean = true
 
   def dumpClasses: Option[String] =
     if (ctx.settings.Ydumpclasses.isDefault) None
@@ -428,7 +420,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
   val MODULE_INSTANCE_FIELD: String = str.MODULE_INSTANCE_FIELD
 
-  def dropModule(str: String) =
+  def dropModule(str: String): String =
     if (!str.isEmpty && str.last == '$') str.take(str.length - 1) else str
 
   def newTermName(prefix: String): Name = prefix.toTermName
@@ -479,7 +471,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   }
 
   // todo: remove
-  def isMaybeBoxed(sym: Symbol) = {
+  def isMaybeBoxed(sym: Symbol): Boolean = {
     (sym == ObjectClass) ||
       (sym == JavaSerializableClass) ||
       (sym == defn.ComparableClass) ||
@@ -1055,13 +1047,13 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
 
   // todo: this product1s should also eventually become name-based pattn matching
   object Literal extends LiteralDeconstructor {
-    def get = field.const
+    def get: Constant = field.const
   }
 
   object Throw extends ThrowDeconstructor {
-    def get = field.args.head
+    def get: Tree = field.args.head
 
-    override def unapply(s: Throw): DottyBackendInterface.this.Throw.type = {
+    override def unapply(s: Throw): Throw.type = {
       if (s.fun.symbol eq defn.throwMethod) {
         field = s
       } else {
@@ -1072,11 +1064,11 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   }
 
   object New extends NewDeconstructor {
-    def get = field.tpt.tpe
+    def get: Type = field.tpt.tpe
   }
 
   object This extends ThisDeconstructor {
-    def get = field.qual.name
+    def get: Name = field.qual.name
     def apply(s: Symbol): This = tpd.This(s.asClass)
   }
 
@@ -1096,15 +1088,15 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   }
 
   object Ident extends IdentDeconstructor {
-    def get = field.name
+    def get: Name = field.name
   }
 
   object Alternative extends AlternativeDeconstructor {
-    def get = field.trees
+    def get: List[Tree] = field.trees
   }
 
   object Constant extends ConstantDeconstructor {
-    def get = field.value
+    def get: Any = field.value
   }
   object ThrownException extends ThrownException {
     def unapply(a: Annotation): Option[Symbol] = None // todo
@@ -1121,7 +1113,7 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     def _2: List[Symbol] = field.vparamss.flatMap(_.map(_.symbol))
     def _3: Tree = field.rhs
 
-    override def unapply(s: LabelDef): DottyBackendInterface.this.LabelDef.type = {
+    override def unapply(s: LabelDef): LabelDef.type = {
       if (s.symbol is Flags.Label) this.field = s
       else this.field = null
       this
@@ -1199,9 +1191,9 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
   }
 
   object Closure extends ClosureDeconstructor {
-    def _1 = field.env
-    def _2 = field.meth
-    def _3 = {
+    def _1: List[Tree] = field.env
+    def _2: Tree = field.meth
+    def _3: Symbol = {
       val t = field.tpt.tpe.typeSymbol
       if (t.exists) t
       else {
@@ -1214,5 +1206,5 @@ class DottyBackendInterface(outputDirectory: AbstractFile, val superCallsMap: Ma
     }
   }
 
-  def currentUnit = ctx.compilationUnit
+  def currentUnit: CompilationUnit = ctx.compilationUnit
 }
diff --git a/compiler/src/dotty/tools/backend/jvm/GenBCode.scala b/compiler/src/dotty/tools/backend/jvm/GenBCode.scala
index ffae0c29ff7f..fe5d3c08aa8a 100644
--- a/compiler/src/dotty/tools/backend/jvm/GenBCode.scala
+++ b/compiler/src/dotty/tools/backend/jvm/GenBCode.scala
@@ -10,6 +10,7 @@ import scala.tools.asm.CustomAttr
 import scala.tools.nsc.backend.jvm._
 import dotty.tools.dotc.transform.SymUtils._
 import dotty.tools.dotc.interfaces
+import dotty.tools.dotc.util.SourceFile
 import java.util.Optional
 
 import dotty.tools.dotc.core._
@@ -20,22 +21,21 @@ import Decorators._
 
 import java.io.DataOutputStream
 
-import dotty.tools.io.Directory
 
 import scala.tools.asm
 import scala.tools.asm.tree._
 import tpd._
 import StdNames._
-import dotty.tools.dotc.core.tasty.{TastyBuffer, TastyHeaderUnpickler, TastyPickler}
+import dotty.tools.dotc.core.tasty.{TastyBuffer, TastyHeaderUnpickler}
 import dotty.tools.io._
 
 class GenBCode extends Phase {
   def phaseName: String = GenBCode.name
   private val entryPoints = new mutable.HashSet[Symbol]()
-  def registerEntryPoint(sym: Symbol) = entryPoints += sym
+  def registerEntryPoint(sym: Symbol): Unit = entryPoints += sym
 
   private val superCallsMap = newMutableSymbolMap[Set[ClassSymbol]]
-  def registerSuperCall(sym: Symbol, calls: ClassSymbol) = {
+  def registerSuperCall(sym: Symbol, calls: ClassSymbol): Unit = {
     val old = superCallsMap.getOrElse(sym, Set.empty)
     superCallsMap.update(sym, old + calls)
   }
@@ -54,7 +54,7 @@ class GenBCode extends Phase {
     entryPoints.clear()
   }
 
-  override def runOn(units: List[CompilationUnit])(implicit ctx: Context) = {
+  override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
     try super.runOn(units)
     finally myOutput match {
       case jar: JarArchive =>
@@ -70,9 +70,9 @@ object GenBCode {
 
 class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInterface)(implicit val ctx: Context) extends BCodeSyncAndTry {
 
-  var tree: Tree = _
+  private[this] var tree: Tree = _
 
-  val sourceFile = ctx.compilationUnit.source
+  private[this] val sourceFile: SourceFile = ctx.compilationUnit.source
 
   /** Convert a `dotty.tools.io.AbstractFile` into a
    *  `dotty.tools.dotc.interfaces.AbstractFile`.
@@ -95,7 +95,7 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
     /* ---------------- q1 ---------------- */
 
     case class Item1(arrivalPos: Int, cd: TypeDef, cunit: CompilationUnit) {
-      def isPoison = { arrivalPos == Int.MaxValue }
+      def isPoison: Boolean = { arrivalPos == Int.MaxValue }
     }
     private val poison1 = Item1(Int.MaxValue, null, ctx.compilationUnit)
     private val q1 = new java.util.LinkedList[Item1]
@@ -108,7 +108,7 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
     case class Item2(arrivalPos: Int,
                      mirror:     SubItem2,
                      plain:      SubItem2) {
-      def isPoison = { arrivalPos == Int.MaxValue }
+      def isPoison: Boolean = { arrivalPos == Int.MaxValue }
     }
 
     private val poison2 = Item2(Int.MaxValue, null, null)
@@ -133,7 +133,7 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
                      mirror:     SubItem3,
                      plain:      SubItem3) {
 
-      def isPoison  = { arrivalPos == Int.MaxValue }
+      def isPoison: Boolean  = { arrivalPos == Int.MaxValue }
     }
     private val i3comparator = new java.util.Comparator[Item3] {
       override def compare(a: Item3, b: Item3) = {
@@ -192,7 +192,7 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
        *  enqueues them in queue-2.
        *
        */
-      def visit(item: Item1) = {
+      def visit(item: Item1): Boolean = {
         val Item1(arrivalPos, cd, cunit) = item
         val claszSymbol = cd.symbol
 
@@ -351,7 +351,7 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
 
     } // end of class BCodePhase.Worker2
 
-    var arrivalPos = 0
+    var arrivalPos: Int = 0
 
     /*
      *  A run of the BCodePhase phase comprises:
@@ -364,7 +364,7 @@ class GenBCodePipeline(val entryPoints: List[Symbol], val int: DottyBackendInter
      *    (c) tear down (closing the classfile-writer and clearing maps)
      *
      */
-    def run(t: Tree) = {
+    def run(t: Tree): Unit = {
       this.tree = t
 
       // val bcodeStart = Statistics.startTimer(BackendStats.bcodeTimer)
diff --git a/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala b/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala
index b898e9496fe9..451ef95c288a 100644
--- a/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala
+++ b/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala
@@ -6,7 +6,6 @@ import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.transform.MegaPhase._
 
-import scala.collection.mutable
 
 /**
  * Verifies that each Label DefDef has only a single address to jump back and
diff --git a/compiler/src/dotty/tools/backend/jvm/scalaPrimitives.scala b/compiler/src/dotty/tools/backend/jvm/scalaPrimitives.scala
index fed7aeb81f63..66c247167ed8 100644
--- a/compiler/src/dotty/tools/backend/jvm/scalaPrimitives.scala
+++ b/compiler/src/dotty/tools/backend/jvm/scalaPrimitives.scala
@@ -14,7 +14,7 @@ import Names.TermName, StdNames._
 import Types.{JavaArrayType, UnspecifiedErrorType, Type}
 import Symbols.{Symbol, NoSymbol}
 
-import scala.collection.{ mutable, immutable }
+import scala.collection.immutable
 
 
 /** Scala primitive operations are represented as methods in `Any` and
diff --git a/compiler/src/dotty/tools/dotc/CompilationUnit.scala b/compiler/src/dotty/tools/dotc/CompilationUnit.scala
index 210894277f92..4cbd228c02a2 100644
--- a/compiler/src/dotty/tools/dotc/CompilationUnit.scala
+++ b/compiler/src/dotty/tools/dotc/CompilationUnit.scala
@@ -12,13 +12,13 @@ import dotty.tools.dotc.transform.SymUtils._
 
 class CompilationUnit(val source: SourceFile) {
 
-  override def toString = source.toString
+  override def toString: String = source.toString
 
   var untpdTree: untpd.Tree = untpd.EmptyTree
 
   var tpdTree: tpd.Tree = tpd.EmptyTree
 
-  def isJava = source.file.name.endsWith(".java")
+  def isJava: Boolean = source.file.name.endsWith(".java")
 
   /** Pickled TASTY binaries, indexed by class. */
   var pickled: Map[ClassSymbol, Array[Byte]] = Map()
@@ -29,7 +29,7 @@ class CompilationUnit(val source: SourceFile) {
   var containsQuotesOrSplices: Boolean = false
 
   /** A structure containing a temporary map for generating inline accessors */
-  val inlineAccessors = new InlineAccessors
+  val inlineAccessors: InlineAccessors = new InlineAccessors
 }
 
 object CompilationUnit {
diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index 564646b446c7..17bf78e54a50 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -3,17 +3,9 @@ package dotc
 
 import core._
 import Contexts._
-import Periods._
-import Symbols._
-import Types._
-import Scopes._
-import typer.{FrontEnd, ImportInfo, RefChecks, Typer}
-import reporting.{ConsoleReporter, Reporter}
+import typer.{FrontEnd, RefChecks}
 import Phases.Phase
 import transform._
-import util.FreshNameCreator
-import core.DenotTransformers.DenotTransformer
-import core.Denotations.SingleDenotation
 import dotty.tools.backend.jvm.{CollectSuperCalls, GenBCode, LabelDefs}
 import dotty.tools.dotc.transform.localopt.StringInterpolatorOpt
 
@@ -126,8 +118,8 @@ class Compiler {
     List(new GenBCode) ::            // Generate JVM bytecode
     Nil
 
-  var runId = 1
-  def nextRunId = {
+  var runId: Int = 1
+  def nextRunId: Int = {
     runId += 1; runId
   }
 
diff --git a/compiler/src/dotty/tools/dotc/Driver.scala b/compiler/src/dotty/tools/dotc/Driver.scala
index 804f5379e8f0..e3d303807619 100644
--- a/compiler/src/dotty/tools/dotc/Driver.scala
+++ b/compiler/src/dotty/tools/dotc/Driver.scala
@@ -5,7 +5,6 @@ import config.CompilerCommand
 import core.Comments.{ContextDoc, ContextDocstrings}
 import core.Contexts.{Context, ContextBase}
 import core.Mode
-import util.DotClass
 import reporting._
 import scala.util.control.NonFatal
 import fromtasty.TASTYCompiler
@@ -38,9 +37,9 @@ class Driver {
       }
     else ctx.reporter
 
-  protected def initCtx = (new ContextBase).initialCtx
+  protected def initCtx: Context = (new ContextBase).initialCtx
 
-  protected def sourcesRequired = true
+  protected def sourcesRequired: Boolean = true
 
   def setup(args: Array[String], rootCtx: Context): (List[String], Context) = {
     val ctx = rootCtx.fresh
diff --git a/compiler/src/dotty/tools/dotc/Resident.scala b/compiler/src/dotty/tools/dotc/Resident.scala
index 7f6c288cc892..0b971dd05953 100644
--- a/compiler/src/dotty/tools/dotc/Resident.scala
+++ b/compiler/src/dotty/tools/dotc/Resident.scala
@@ -27,7 +27,7 @@ class Resident extends Driver {
 
   object residentCompiler extends Compiler
 
-  override def sourcesRequired = false
+  override def sourcesRequired: Boolean = false
 
   private val quit = ":q"
   private val reset = ":reset"
diff --git a/compiler/src/dotty/tools/dotc/Run.scala b/compiler/src/dotty/tools/dotc/Run.scala
index 52694c0e5662..f7e88c124b57 100644
--- a/compiler/src/dotty/tools/dotc/Run.scala
+++ b/compiler/src/dotty/tools/dotc/Run.scala
@@ -5,17 +5,15 @@ import core._
 import Contexts._
 import Periods._
 import Symbols._
-import Phases._
 import Types._
 import Scopes._
-import typer.{FrontEnd, ImportInfo, RefChecks, Typer}
+import typer.{ImportInfo, Typer}
 import Decorators._
 import io.{AbstractFile, PlainFile}
 
 import scala.io.Codec
 import util.{Set => _, _}
 import reporting.Reporter
-import transform.TreeChecker
 import rewrites.Rewrites
 import java.io.{BufferedWriter, OutputStreamWriter}
 
@@ -26,7 +24,6 @@ import parsing.JavaParsers.JavaParser
 import typer.ImplicitRunInfo
 import collection.mutable
 
-import scala.annotation.tailrec
 import dotty.tools.io.VirtualFile
 
 import scala.util.control.NonFatal
@@ -67,7 +64,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   private[this] var myCtx = rootContext(ictx)
 
   /** The context created for this run */
-  def runContext = myCtx
+  def runContext: Context = myCtx
 
   protected[this] implicit def ctx: Context = myCtx
   assert(ctx.runId <= Periods.MaxPossibleRunId)
@@ -131,7 +128,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
    *  or we need to assemble phases on each run, and take -Yskip, -Ystop into
    *  account. I think the latter would be preferable.
    */
-  def compileSources(sources: List[SourceFile]) =
+  def compileSources(sources: List[SourceFile]): Unit =
     if (sources forall (_.exists)) {
       units = sources map (new CompilationUnit(_))
       compileUnits()
@@ -267,7 +264,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     r
   }
 
-  override def reset() = {
+  override def reset(): Unit = {
     super[ImplicitRunInfo].reset()
     super[ConstraintRunInfo].reset()
     myCtx = null
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index b22e31492156..60360a268993 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -4,10 +4,9 @@ package ast
 
 import core._
 import util.Positions._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
-import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
+import Symbols._, StdNames._, Trees._
 import Decorators._, transform.SymUtils._
 import NameKinds.{UniqueName, EvidenceParamName, DefaultGetterName}
-import language.higherKinds
 import typer.FrontEnd
 import collection.mutable.ListBuffer
 import reporting.diagnostic.messages._
@@ -38,15 +37,15 @@ object desugar {
 // ----- DerivedTypeTrees -----------------------------------
 
   class SetterParamTree extends DerivedTypeTree {
-    def derivedTree(sym: Symbol)(implicit ctx: Context) = tpd.TypeTree(sym.info.resultType)
+    def derivedTree(sym: Symbol)(implicit ctx: Context): tpd.TypeTree = tpd.TypeTree(sym.info.resultType)
   }
 
   class TypeRefTree extends DerivedTypeTree {
-    def derivedTree(sym: Symbol)(implicit ctx: Context) = tpd.TypeTree(sym.typeRef)
+    def derivedTree(sym: Symbol)(implicit ctx: Context): tpd.TypeTree = tpd.TypeTree(sym.typeRef)
   }
 
   class TermRefTree extends DerivedTypeTree {
-    def derivedTree(sym: Symbol)(implicit ctx: Context) = tpd.ref(sym)
+    def derivedTree(sym: Symbol)(implicit ctx: Context): tpd.Tree = tpd.ref(sym)
   }
 
   /** A type tree that computes its type from an existing parameter.
@@ -60,7 +59,7 @@ object desugar {
      *  be completed so that OriginalSymbol attachments are pushed to DerivedTypeTrees
      *  in apply/unapply methods.
      */
-    override def ensureCompletions(implicit ctx: Context) =
+    override def ensureCompletions(implicit ctx: Context): Unit =
       if (!(ctx.owner is Package))
         if (ctx.owner.isClass) {
           ctx.owner.ensureCompleted()
@@ -82,7 +81,7 @@ object desugar {
      *
      *       parameter name  ==  reference name ++ suffix
      */
-    def derivedTree(sym: Symbol)(implicit ctx: Context) = {
+    def derivedTree(sym: Symbol)(implicit ctx: Context): tpd.TypeTree = {
       val relocate = new TypeMap {
         val originalOwner = sym.owner
         def apply(tp: Type) = tp match {
@@ -115,7 +114,7 @@ object desugar {
     TypeDef(sym.name, new DerivedFromParamTree("").watching(sym)).withFlags(TypeParam)
 
   /** A value definition copied from `vdef` with a tpt typetree derived from it */
-  def derivedTermParam(vdef: ValDef) =
+  def derivedTermParam(vdef: ValDef): ValDef =
     cpy.ValDef(vdef)(
       tpt = new DerivedFromParamTree("") withPos vdef.tpt.pos watching vdef)
 
@@ -151,7 +150,7 @@ object desugar {
     else vdef
   }
 
-  def makeImplicitParameters(tpts: List[Tree], forPrimaryConstructor: Boolean = false)(implicit ctx: Context) =
+  def makeImplicitParameters(tpts: List[Tree], forPrimaryConstructor: Boolean = false)(implicit ctx: Context): List[ValDef] =
     for (tpt <- tpts) yield {
        val paramFlags: FlagSet = if (forPrimaryConstructor) PrivateLocalParamAccessor else Param
        val epname = EvidenceParamName.fresh()
@@ -622,10 +621,10 @@ object desugar {
         case _ =>
           Nil
       }
-      cpy.TypeDef(cdef)(
+      cpy.TypeDef(cdef: TypeDef)(
         name = className,
         rhs = cpy.Template(impl)(constr, parents1, self1,
-          tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths))
+          tparamAccessors ::: vparamAccessors ::: normalizedBody ::: caseClassMeths)): TypeDef
     }
 
     // install the watch on classTycon
@@ -637,7 +636,7 @@ object desugar {
     flatTree(cdef1 :: companions ::: implicitWrappers)
   }
 
-  val AccessOrSynthetic = AccessFlags | Synthetic
+  val AccessOrSynthetic: FlagSet = AccessFlags | Synthetic
 
   /** Expand
    *
@@ -763,7 +762,7 @@ object desugar {
   }
 
   /** Expand variable identifier x to x @ _ */
-  def patternVar(tree: Tree)(implicit ctx: Context) = {
+  def patternVar(tree: Tree)(implicit ctx: Context): Bind = {
     val Ident(name) = tree
     Bind(name, Ident(nme.WILDCARD)).withPos(tree.pos)
   }
@@ -838,7 +837,7 @@ object desugar {
    *      def $anonfun(params) = body
    *      Closure($anonfun)
    */
-  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree(), isImplicit: Boolean)(implicit ctx: Context) =
+  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = TypeTree(), isImplicit: Boolean)(implicit ctx: Context): Block =
     Block(
       DefDef(nme.ANON_FUN, Nil, params :: Nil, tpt, body).withMods(synthetic | Artifact),
       Closure(Nil, Ident(nme.ANON_FUN), if (isImplicit) ImplicitEmptyTree else EmptyTree))
@@ -853,7 +852,7 @@ object desugar {
    *
    *       (x$1, ..., x$n) => (x$0, ..., x${n-1} @unchecked) match { cases }
    */
-  def makeCaseLambda(cases: List[CaseDef], nparams: Int = 1, unchecked: Boolean = true)(implicit ctx: Context) = {
+  def makeCaseLambda(cases: List[CaseDef], nparams: Int = 1, unchecked: Boolean = true)(implicit ctx: Context): Function = {
     val params = (1 to nparams).toList.map(makeSyntheticParameter(_))
     val selector = makeTuple(params.map(p => Ident(p.name)))
 
@@ -897,7 +896,7 @@ object desugar {
    *  following `fullName`. This is necessary so that we avoid reading an annotation from
    *  the classpath that is also compiled from source.
    */
-  def makeAnnotated(fullName: String, tree: Tree)(implicit ctx: Context) = {
+  def makeAnnotated(fullName: String, tree: Tree)(implicit ctx: Context): Annotated = {
     val parts = fullName.split('.')
     val ttree = ctx.typerPhase match {
       case phase: FrontEnd if phase.stillToBeEntered(parts.last) =>
@@ -908,7 +907,7 @@ object desugar {
       case _ =>
         TypeTree(ctx.requiredClass(fullName).typeRef)
     }
-    Annotated(tree, untpd.New(ttree, Nil))
+    Annotated(tree, New(ttree, Nil))
   }
 
   private def derivedValDef(original: Tree, named: NameTree, tpt: Tree, rhs: Tree, mods: Modifiers)(implicit ctx: Context) = {
diff --git a/compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala b/compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala
index 77fe8dd97379..69b0bf780b75 100644
--- a/compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala
+++ b/compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala
@@ -4,9 +4,8 @@ package ast
 
 import core._
 import util.Positions._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
-import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
+import Symbols._, StdNames._, Trees._
 import Decorators._
-import collection.mutable.ListBuffer
 import util.Property
 import typer.ErrorReporting._
 
@@ -15,14 +14,13 @@ import scala.annotation.internal.sharable
 /** Helper methods to desugar enums */
 object DesugarEnums {
   import untpd._
-  import desugar.DerivedFromParamTree
 
   @sharable object CaseKind extends Enumeration {
-    val Simple, Object, Class = Value
+    val Simple, Object, Class: Value = Value
   }
 
   /** Attachment containing the number of enum cases and the smallest kind that was seen so far. */
-  val EnumCaseCount = new Property.Key[(Int, CaseKind.Value)]
+  val EnumCaseCount: Property.Key[(Int, DesugarEnums.CaseKind.Value)] = new Property.Key
 
   /** The enumeration class that belongs to an enum case. This works no matter
    *  whether the case is still in the enum class or it has been transferred to the
@@ -66,11 +64,11 @@ object DesugarEnums {
   }
 
   /** A type tree referring to `enumClass` */
-  def enumClassRef(implicit ctx: Context) =
+  def enumClassRef(implicit ctx: Context): Tree =
     if (enumClass.exists) TypeTree(enumClass.typeRef) else TypeTree()
 
   /** Add implied flags to an enum class or an enum case */
-  def addEnumFlags(cdef: TypeDef)(implicit ctx: Context) =
+  def addEnumFlags(cdef: TypeDef)(implicit ctx: Context): TypeDef =
     if (cdef.mods.isEnumClass) cdef.withMods(cdef.mods.withFlags(cdef.mods.flags | Abstract | Sealed))
     else if (isEnumCase(cdef)) cdef.withMods(cdef.mods.withFlags(cdef.mods.flags | Final))
     else cdef
diff --git a/compiler/src/dotty/tools/dotc/ast/Positioned.scala b/compiler/src/dotty/tools/dotc/ast/Positioned.scala
index 87d46eb9a9bf..9db97de44590 100644
--- a/compiler/src/dotty/tools/dotc/ast/Positioned.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Positioned.scala
@@ -2,7 +2,6 @@ package dotty.tools.dotc
 package ast
 
 import util.Positions._
-import util.DotClass
 import core.Contexts.Context
 import core.Decorators._
 import core.Flags.JavaDefined
@@ -51,7 +50,7 @@ abstract class Positioned extends Product {
    *  any checks of consistency with - or updates of - other positions.
    *  Called from Unpickler when entering positions.
    */
-  private[dotc] def setPosUnchecked(pos: Position) = curPos = pos
+  private[dotc] def setPosUnchecked(pos: Position): Unit = curPos = pos
 
   /** If any children of this node do not have positions,
    *  fit their positions between the positions of the known subtrees
diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index 73c20430c841..4f59b51a9a53 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -4,15 +4,13 @@ package ast
 
 import core._
 import Flags._, Trees._, Types._, Contexts._
-import Names._, StdNames._, NameOps._, Decorators._, Symbols._
-import util.HashSet
+import Names._, StdNames._, NameOps._, Symbols._
 import typer.ConstFold
 import reporting.trace
 
 import scala.annotation.tailrec
 
 trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
-  import TreeInfo._
 
   // Note: the <: Type constraint looks necessary (and is needed to make the file compile in dotc).
   // But Scalac accepts the program happily without it. Need to find out why.
@@ -26,7 +24,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case _ => false
   }
 
-  def isOpAssign(tree: Tree) = unsplice(tree) match {
+  def isOpAssign(tree: Tree): Boolean = unsplice(tree) match {
     case Apply(fn, _ :: _) =>
       unsplice(fn) match {
         case Select(_, name) if name.isOpAssignmentName => true
@@ -122,7 +120,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     case _ => false
   }
 
-  def isSuperSelection(tree: Tree) = unsplice(tree) match {
+  def isSuperSelection(tree: Tree): Boolean = unsplice(tree) match {
     case Select(Super(_, _), _) => true
     case _ => false
   }
@@ -163,7 +161,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   }
 
   /** Is name a left-associative operator? */
-  def isLeftAssoc(operator: Name) = !operator.isEmpty && (operator.toSimpleName.last != ':')
+  def isLeftAssoc(operator: Name): Boolean = !operator.isEmpty && (operator.toSimpleName.last != ':')
 
   /** can this type be a type pattern? */
   def mayBeTypePat(tree: Tree): Boolean = unsplice(tree) match {
@@ -196,7 +194,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   }*/
 
   /** Does this argument list end with an argument of the form <expr> : _* ? */
-  def isWildcardStarArgList(trees: List[Tree])(implicit ctx: Context) =
+  def isWildcardStarArgList(trees: List[Tree])(implicit ctx: Context): Boolean =
     trees.nonEmpty && isWildcardStarArg(trees.last)
 
   /** Is the argument a wildcard argument of the form `_` or `x @ _`?
@@ -207,28 +205,28 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
   }
 
   /** Does this list contain a named argument tree? */
-  def hasNamedArg(args: List[Any]) = args exists isNamedArg
-  val isNamedArg = (arg: Any) => arg.isInstanceOf[Trees.NamedArg[_]]
+  def hasNamedArg(args: List[Any]): Boolean = args exists isNamedArg
+  val isNamedArg: Any => Boolean = (arg: Any) => arg.isInstanceOf[Trees.NamedArg[_]]
 
   /** Is this pattern node a catch-all (wildcard or variable) pattern? */
-  def isDefaultCase(cdef: CaseDef) = cdef match {
+  def isDefaultCase(cdef: CaseDef): Boolean = cdef match {
     case CaseDef(pat, EmptyTree, _) => isWildcardArg(pat)
     case _                            => false
   }
 
   /** Is this pattern node a synthetic catch-all case, added during PartialFuction synthesis before we know
     * whether the user provided cases are exhaustive. */
-  def isSyntheticDefaultCase(cdef: CaseDef) = unsplice(cdef) match {
+  def isSyntheticDefaultCase(cdef: CaseDef): Boolean = unsplice(cdef) match {
     case CaseDef(Bind(nme.DEFAULT_CASE, _), EmptyTree, _) => true
     case _                                                  => false
   }
 
   /** Does this CaseDef catch Throwable? */
-  def catchesThrowable(cdef: CaseDef)(implicit ctx: Context) =
+  def catchesThrowable(cdef: CaseDef)(implicit ctx: Context): Boolean =
     catchesAllOf(cdef, defn.ThrowableType)
 
   /** Does this CaseDef catch everything of a certain Type? */
-  def catchesAllOf(cdef: CaseDef, threshold: Type)(implicit ctx: Context) =
+  def catchesAllOf(cdef: CaseDef, threshold: Type)(implicit ctx: Context): Boolean =
     isDefaultCase(cdef) ||
     cdef.guard.isEmpty && {
       unbind(cdef.pat) match {
@@ -238,7 +236,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     }
 
   /** Is this case guarded? */
-  def isGuardedCase(cdef: CaseDef) = cdef.guard ne EmptyTree
+  def isGuardedCase(cdef: CaseDef): Boolean = cdef.guard ne EmptyTree
 
   /** The underlying pattern ignoring any bindings */
   def unbind(x: Tree): Tree = unsplice(x) match {
@@ -287,7 +285,6 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
 }
 
 trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped] =>
-  import TreeInfo._
   import untpd._
 
   /** The underlying tree when stripping any TypedSplice or Parens nodes */
@@ -300,7 +297,7 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
   /** True iff definition is a val or def with no right-hand-side, or it
    *  is an abstract typoe declaration
    */
-  def lacksDefinition(mdef: MemberDef)(implicit ctx: Context) = mdef match {
+  def lacksDefinition(mdef: MemberDef)(implicit ctx: Context): Boolean = mdef match {
     case mdef: ValOrDefDef =>
       mdef.unforcedRhs == EmptyTree && !mdef.name.isConstructorName && !mdef.mods.is(TermParamOrAccessor)
     case mdef: TypeDef =>
@@ -422,11 +419,11 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
   private def minOf(l0: PurityLevel, ls: List[PurityLevel]) = (l0 /: ls)(_ min _)
 
-  def isSimplyPure(tree: Tree)(implicit ctx: Context) = exprPurity(tree) == SimplyPure
-  def isPureExpr(tree: Tree)(implicit ctx: Context) = exprPurity(tree) >= Pure
-  def isIdempotentExpr(tree: Tree)(implicit ctx: Context) = exprPurity(tree) >= Idempotent
+  def isSimplyPure(tree: Tree)(implicit ctx: Context): Boolean = exprPurity(tree) == SimplyPure
+  def isPureExpr(tree: Tree)(implicit ctx: Context): Boolean = exprPurity(tree) >= Pure
+  def isIdempotentExpr(tree: Tree)(implicit ctx: Context): Boolean = exprPurity(tree) >= Idempotent
 
-  def isPureBinding(tree: Tree)(implicit ctx: Context) = statPurity(tree) >= Pure
+  def isPureBinding(tree: Tree)(implicit ctx: Context): Boolean = statPurity(tree) >= Pure
 
   /** The purity level of this reference.
    *  @return
@@ -447,9 +444,9 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
     else SimplyPure
   }
 
-  def isPureRef(tree: Tree)(implicit ctx: Context) =
+  def isPureRef(tree: Tree)(implicit ctx: Context): Boolean =
     refPurity(tree) == SimplyPure
-  def isIdempotentRef(tree: Tree)(implicit ctx: Context) =
+  def isIdempotentRef(tree: Tree)(implicit ctx: Context): Boolean =
     refPurity(tree) >= Idempotent
 
   /** If `tree` is a constant expression, its value as a Literal,
@@ -512,7 +509,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   /** Is tree a reference to a mutable variable, or to a potential getter
    *  that has a setter in the same class?
    */
-  def isVariableOrGetter(tree: Tree)(implicit ctx: Context) = {
+  def isVariableOrGetter(tree: Tree)(implicit ctx: Context): Boolean = {
     def sym = tree.symbol
     def isVar    = sym is Mutable
     def isGetter =
@@ -620,7 +617,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   }
 
   /** Is this pattern node a catch-all or type-test pattern? */
-  def isCatchCase(cdef: CaseDef)(implicit ctx: Context) = cdef match {
+  def isCatchCase(cdef: CaseDef)(implicit ctx: Context): Boolean = cdef match {
     case CaseDef(Typed(Ident(nme.WILDCARD), tpt), EmptyTree, _) =>
       isSimpleThrowable(tpt.tpe)
     case CaseDef(Bind(_, Typed(Ident(nme.WILDCARD), tpt)), EmptyTree, _) =>
@@ -734,7 +731,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   /** The qualifier part of a Select or Ident.
    *  For an Ident, this is the `This` of the current class.
    */
-  def qualifier(tree: Tree)(implicit ctx: Context) = tree match {
+  def qualifier(tree: Tree)(implicit ctx: Context): Tree = tree match {
     case Select(qual, _) => qual
     case tree: Ident => desugarIdentPrefix(tree)
     case _ => This(ctx.owner.enclosingClass.asClass)
@@ -743,7 +740,7 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
   /** Is this a selection of a member of a structural type that is not a member
    *  of an underlying class or trait?
    */
-  def isStructuralTermSelect(tree: Tree)(implicit ctx: Context) = tree match {
+  def isStructuralTermSelect(tree: Tree)(implicit ctx: Context): Boolean = tree match {
     case tree: Select =>
       def hasRefinement(qualtpe: Type): Boolean = qualtpe.dealias match {
         case RefinedType(parent, rname, rinfo) =>
@@ -796,12 +793,12 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
 
 object TreeInfo {
   class PurityLevel(val x: Int) extends AnyVal {
-    def >= (that: PurityLevel) = x >= that.x
-    def min(that: PurityLevel) = new PurityLevel(x min that.x)
+    def >= (that: PurityLevel): Boolean = x >= that.x
+    def min(that: PurityLevel): PurityLevel = new PurityLevel(x min that.x)
   }
 
-  val SimplyPure = new PurityLevel(3)
-  val Pure = new PurityLevel(2)
-  val Idempotent = new PurityLevel(1)
-  val Impure = new PurityLevel(0)
+  val SimplyPure: PurityLevel = new PurityLevel(3)
+  val Pure: PurityLevel = new PurityLevel(2)
+  val Idempotent: PurityLevel = new PurityLevel(1)
+  val Impure: PurityLevel = new PurityLevel(0)
 }
diff --git a/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala b/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala
index 856597b4b7ff..25269c17e863 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeTypeMap.scala
@@ -3,9 +3,9 @@ package dotc
 package ast
 
 import core._
-import Types._, Contexts._, Constants._, Names._, Flags._
-import SymDenotations._, Symbols._, Annotations._, Trees._, Symbols._
-import Denotations._, Decorators._
+import Types._, Contexts._
+import Symbols._, Annotations._, Trees._, Symbols._
+import Decorators._
 import dotty.tools.dotc.transform.SymUtils._
 import core.tasty.TreePickler.Hole
 
@@ -42,7 +42,7 @@ class TreeTypeMap(
   import tpd._
 
   /** If `sym` is one of `oldOwners`, replace by corresponding symbol in `newOwners` */
-  def mapOwner(sym: Symbol) = sym.subst(oldOwners, newOwners)
+  def mapOwner(sym: Symbol): Symbol = sym.subst(oldOwners, newOwners)
 
   /** Replace occurrences of `This(oldOwner)` in some prefix of a type
    *  by the corresponding `This(newOwner)`.
@@ -59,7 +59,7 @@ class TreeTypeMap(
     }
   }
 
-  def mapType(tp: Type) =
+  def mapType(tp: Type): Type =
     mapOwnerThis(typeMap(tp).substSym(substFrom, substTo))
 
   private def updateDecls(prevStats: List[Tree], newStats: List[Tree]): Unit =
@@ -128,7 +128,7 @@ class TreeTypeMap(
       }
   }
 
-  override def transformStats(trees: List[tpd.Tree])(implicit ctx: Context) =
+  override def transformStats(trees: List[tpd.Tree])(implicit ctx: Context): List[Tree] =
     transformDefs(trees)._2
 
   def transformDefs[TT <: tpd.Tree](trees: List[TT])(implicit ctx: Context): (TreeTypeMap, List[TT]) = {
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 7e6aaa86f25c..453516880ab9 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -5,18 +5,14 @@ package ast
 import core._
 import Types._, Names._, NameOps._, Flags._, util.Positions._, Contexts._, Constants._
 import SymDenotations._, Symbols._, Denotations._, StdNames._, Comments._
-import annotation.tailrec
 import language.higherKinds
-import collection.IndexedSeqOptimized
-import collection.immutable.IndexedSeq
 import collection.mutable.ListBuffer
-import parsing.Tokens.Token
 import printing.Printer
-import util.{Stats, Attachment, Property, DotClass}
+import printing.Texts.Text
+import util.{Stats, Attachment, Property}
 import config.Config
 import annotation.internal.sharable
 import annotation.unchecked.uncheckedVariance
-import language.implicitConversions
 
 object Trees {
 
@@ -29,10 +25,10 @@ object Trees {
   type Untyped = Null
 
   /** The total number of created tree nodes, maintained if Stats.enabled */
-  @sharable var ntrees = 0
+  @sharable var ntrees: Int = 0
 
   /** Property key for trees with documentation strings attached */
-  val DocComment = new Property.StickyKey[Comment]
+  val DocComment: Property.StickyKey[Comments.Comment] = new Property.StickyKey
 
   @sharable private[this] var nextId = 0 // for debugging
 
@@ -74,7 +70,7 @@ object Trees {
      */
     @sharable private var myUniqueId: Int = nxId
 
-    def uniqueId = myUniqueId
+    def uniqueId: Int = myUniqueId
 
     /** The type  constructor at the root of the tree */
     type ThisTree[T >: Untyped] <: Tree[T]
@@ -86,7 +82,7 @@ object Trees {
      *  which implements copy-on-write. Another use-case is in method interpolateAndAdapt in Typer,
      *  where we overwrite with a simplified version of the type itself.
      */
-    private[dotc] def overwriteType(tpe: T) =
+    private[dotc] def overwriteType(tpe: T): Unit =
       myTpe = tpe
 
     /** The type of the tree. In case of an untyped tree,
@@ -212,7 +208,7 @@ object Trees {
      */
     def foreachInThicket(op: Tree[T] => Unit): Unit = op(this)
 
-    override def toText(printer: Printer) = printer.toText(this)
+    override def toText(printer: Printer): Text = printer.toText(this)
 
     def sameTree(that: Tree[_]): Boolean = {
       def isSame(x: Any, y: Any): Boolean =
@@ -240,7 +236,7 @@ object Trees {
     }
 
     override def hashCode(): Int = uniqueId // for debugging; was: System.identityHashCode(this)
-    override def equals(that: Any) = this eq that.asInstanceOf[AnyRef]
+    override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
 
     override def clone: Tree[T] = {
       val tree = super.clone.asInstanceOf[Tree[T]]
@@ -260,7 +256,7 @@ object Trees {
    */
   trait TypTree[-T >: Untyped] extends Tree[T] {
     type ThisTree[-T >: Untyped] <: TypTree[T]
-    override def isType = true
+    override def isType: Boolean = true
   }
 
   /** Instances of this class are trees for which isTerm is definitely true.
@@ -268,7 +264,7 @@ object Trees {
    */
   trait TermTree[-T >: Untyped] extends Tree[T] {
     type ThisTree[-T >: Untyped] <: TermTree[T]
-    override def isTerm = true
+    override def isTerm: Boolean = true
   }
 
   /** Instances of this class are trees which are not terms but are legal
@@ -276,13 +272,13 @@ object Trees {
    */
   trait PatternTree[-T >: Untyped] extends Tree[T] {
     type ThisTree[-T >: Untyped] <: PatternTree[T]
-    override def isPattern = true
+    override def isPattern: Boolean = true
   }
 
   /** Tree's denotation can be derived from its type */
   abstract class DenotingTree[-T >: Untyped] extends Tree[T] {
     type ThisTree[-T >: Untyped] <: DenotingTree[T]
-    override def denot(implicit ctx: Context) = typeOpt match {
+    override def denot(implicit ctx: Context): Denotation = typeOpt match {
       case tpe: NamedType => tpe.denot
       case tpe: ThisType => tpe.cls.denot
       case tpe: AnnotatedType => tpe.stripAnnots match {
@@ -301,8 +297,8 @@ object Trees {
     type ThisTree[-T >: Untyped] <: ProxyTree[T]
     def forwardTo: Tree[T]
     override def denot(implicit ctx: Context): Denotation = forwardTo.denot
-    override def isTerm = forwardTo.isTerm
-    override def isType = forwardTo.isType
+    override def isTerm: Boolean = forwardTo.isTerm
+    override def isType: Boolean = forwardTo.isType
   }
 
   /** Tree has a name */
@@ -315,15 +311,15 @@ object Trees {
   abstract class RefTree[-T >: Untyped] extends NameTree[T] {
     type ThisTree[-T >: Untyped] <: RefTree[T]
     def qualifier: Tree[T]
-    override def isType = name.isTypeName
-    override def isTerm = name.isTermName
+    override def isType: Boolean = name.isTypeName
+    override def isTerm: Boolean = name.isTermName
   }
 
   /** Tree defines a new symbol */
   trait DefTree[-T >: Untyped] extends DenotingTree[T] {
     type ThisTree[-T >: Untyped] <: DefTree[T]
-    override def isDef = true
-    def namedType = tpe.asInstanceOf[NamedType]
+    override def isDef: Boolean = true
+    def namedType: NamedType = tpe.asInstanceOf[NamedType]
   }
 
   /** Tree defines a new symbol and carries modifiers.
@@ -354,7 +350,7 @@ object Trees {
       asInstanceOf[ThisTree[Untyped]]
     }
 
-    protected def setMods(mods: untpd.Modifiers) = myMods = mods
+    protected def setMods(mods: untpd.Modifiers): Unit = myMods = mods
 
     /** The position of the name defined by this definition.
      *  This is a point position if the definition is synthetic, or a range position
@@ -362,7 +358,7 @@ object Trees {
      *  It might also be that the definition does not have a position (for instance when synthesized by
      *  a calling chain from `viewExists`), in that case the return position is NoPosition.
      */
-    def namePos =
+    def namePos: Position =
       if (pos.exists) {
         val point = pos.point
         if (rawMods.is(Synthetic) || name.toTermName == nme.ERROR) Position(point)
@@ -395,12 +391,12 @@ object Trees {
     extends Ident[T](name) {
     override def isBackquoted: Boolean = true
 
-    override def toString = s"BackquotedIdent($name)"
+    override def toString: String = s"BackquotedIdent($name)"
   }
 
   class SearchFailureIdent[-T >: Untyped] private[ast] (name: Name)
     extends Ident[T](name) {
-    override def toString = s"SearchFailureIdent($name)"
+    override def toString: String = s"SearchFailureIdent($name)"
   }
 
   /** qualifier.name, or qualifier#name, if qualifier is a type */
@@ -411,7 +407,7 @@ object Trees {
 
   class SelectWithSig[-T >: Untyped] private[ast] (qualifier: Tree[T], name: Name, val sig: Signature)
     extends Select[T](qualifier, name) {
-    override def toString = s"SelectWithSig($qualifier, $name, $sig)"
+    override def toString: String = s"SelectWithSig($qualifier, $name, $sig)"
   }
 
   /** qual.this */
@@ -433,14 +429,14 @@ object Trees {
   case class Super[-T >: Untyped] private[ast] (qual: Tree[T], mix: untpd.Ident)
     extends ProxyTree[T] with TermTree[T] {
     type ThisTree[-T >: Untyped] = Super[T]
-    def forwardTo = qual
+    def forwardTo: Tree[T] = qual
   }
 
   abstract class GenericApply[-T >: Untyped] extends ProxyTree[T] with TermTree[T] {
     type ThisTree[-T >: Untyped] <: GenericApply[T]
     val fun: Tree[T]
     val args: List[Tree[T]]
-    def forwardTo = fun
+    def forwardTo: Tree[T] = fun
   }
 
   /** fun(args) */
@@ -471,7 +467,7 @@ object Trees {
   case class Typed[-T >: Untyped] private[ast] (expr: Tree[T], tpt: Tree[T])
     extends ProxyTree[T] with TermTree[T] {
     type ThisTree[-T >: Untyped] = Typed[T]
-    def forwardTo = expr
+    def forwardTo: Tree[T] = expr
   }
 
   /** name = arg, in a parameter list */
@@ -582,7 +578,7 @@ object Trees {
   /** Array(elems) */
   class JavaSeqLiteral[T >: Untyped] private[ast] (elems: List[Tree[T]], elemtpt: Tree[T])
     extends SeqLiteral(elems, elemtpt) {
-    override def toString = s"JavaSeqLiteral($elems, $elemtpt)"
+    override def toString: String = s"JavaSeqLiteral($elems, $elemtpt)"
   }
 
   /** A tree representing inlined code.
@@ -604,15 +600,15 @@ object Trees {
   case class Inlined[-T >: Untyped] private[ast] (call: tpd.Tree, bindings: List[MemberDef[T]], expansion: Tree[T])
     extends Tree[T] {
     type ThisTree[-T >: Untyped] = Inlined[T]
-    override def initialPos = call.pos
+    override def initialPos: Position = call.pos
   }
 
   /** A type tree that represents an existing or inferred type */
   case class TypeTree[-T >: Untyped] ()
     extends DenotingTree[T] with TypTree[T] {
     type ThisTree[-T >: Untyped] = TypeTree[T]
-    override def isEmpty = !hasType
-    override def toString =
+    override def isEmpty: Boolean = !hasType
+    override def toString: String =
       s"TypeTree${if (hasType) s"[$typeOpt]" else ""}"
   }
 
@@ -643,14 +639,14 @@ object Trees {
   case class RefinedTypeTree[-T >: Untyped] private[ast] (tpt: Tree[T], refinements: List[Tree[T]])
     extends ProxyTree[T] with TypTree[T] {
     type ThisTree[-T >: Untyped] = RefinedTypeTree[T]
-    def forwardTo = tpt
+    def forwardTo: Tree[T] = tpt
   }
 
   /** tpt[args] */
   case class AppliedTypeTree[-T >: Untyped] private[ast] (tpt: Tree[T], args: List[Tree[T]])
     extends ProxyTree[T] with TypTree[T] {
     type ThisTree[-T >: Untyped] = AppliedTypeTree[T]
-    def forwardTo = tpt
+    def forwardTo: Tree[T] = tpt
   }
 
   /** [typeparams] -> tpt */
@@ -681,8 +677,8 @@ object Trees {
   case class Bind[-T >: Untyped] private[ast] (name: Name, body: Tree[T])
     extends NameTree[T] with DefTree[T] with PatternTree[T] {
     type ThisTree[-T >: Untyped] = Bind[T]
-    override def isType = name.isTypeName
-    override def isTerm = name.isTermName
+    override def isType: Boolean = name.isTypeName
+    override def isTerm: Boolean = name.isTermName
   }
 
   /** tree_1 | ... | tree_n */
@@ -715,8 +711,8 @@ object Trees {
     extends ValOrDefDef[T] {
     type ThisTree[-T >: Untyped] = ValDef[T]
     assert(isEmpty || tpt != genericEmptyTree)
-    def unforced = preRhs
-    protected def force(x: AnyRef) = preRhs = x
+    def unforced: LazyTree = preRhs
+    protected def force(x: AnyRef): Unit = preRhs = x
   }
 
   /** mods def name[tparams](vparams_1)...(vparams_n): tpt = rhs */
@@ -725,8 +721,8 @@ object Trees {
     extends ValOrDefDef[T] {
     type ThisTree[-T >: Untyped] = DefDef[T]
     assert(tpt != genericEmptyTree)
-    def unforced = preRhs
-    protected def force(x: AnyRef) = preRhs = x
+    def unforced: LazyTree = preRhs
+    protected def force(x: AnyRef): Unit = preRhs = x
   }
 
   /** mods class name template     or
@@ -739,16 +735,16 @@ object Trees {
     type ThisTree[-T >: Untyped] = TypeDef[T]
 
     /** Is this a definition of a class? */
-    def isClassDef = rhs.isInstanceOf[Template[_]]
+    def isClassDef: Boolean = rhs.isInstanceOf[Template[_]]
   }
 
   /** extends parents { self => body } */
   case class Template[-T >: Untyped] private[ast] (constr: DefDef[T], parents: List[Tree[T]], self: ValDef[T], private var preBody: LazyTreeList)
     extends DefTree[T] with WithLazyField[List[Tree[T]]] {
     type ThisTree[-T >: Untyped] = Template[T]
-    def unforcedBody = unforced
-    def unforced = preBody
-    protected def force(x: AnyRef) = preBody = x
+    def unforcedBody: LazyTreeList = unforced
+    def unforced: LazyTreeList = preBody
+    protected def force(x: AnyRef): Unit = preBody = x
     def body(implicit ctx: Context): List[Tree[T]] = forceIfLazy
   }
 
@@ -765,20 +761,20 @@ object Trees {
   case class PackageDef[-T >: Untyped] private[ast] (pid: RefTree[T], stats: List[Tree[T]])
     extends ProxyTree[T] {
     type ThisTree[-T >: Untyped] = PackageDef[T]
-    def forwardTo = pid
+    def forwardTo: RefTree[T] = pid
   }
 
   /** arg @annot */
   case class Annotated[-T >: Untyped] private[ast] (arg: Tree[T], annot: Tree[T])
     extends ProxyTree[T] {
     type ThisTree[-T >: Untyped] = Annotated[T]
-    def forwardTo = arg
+    def forwardTo: Tree[T] = arg
   }
 
   trait WithoutTypeOrPos[-T >: Untyped] extends Tree[T] {
-    override def withTypeUnchecked(tpe: Type) = this.asInstanceOf[ThisTree[Type]]
-    override def pos = NoPosition
-    override def setPos(pos: Position) = {}
+    override def withTypeUnchecked(tpe: Type): ThisTree[Type] = this.asInstanceOf[ThisTree[Type]]
+    override def pos: Position = NoPosition
+    override def setPos(pos: Position): Unit = {}
   }
 
   /** Temporary class that results from translation of ModuleDefs
@@ -793,7 +789,7 @@ object Trees {
     type ThisTree[-T >: Untyped] = Thicket[T]
     override def isEmpty: Boolean = trees.isEmpty
     override def toList: List[Tree[T]] = flatten(trees)
-    override def toString = if (isEmpty) "EmptyTree" else "Thicket(" + trees.mkString(", ") + ")"
+    override def toString: String = if (isEmpty) "EmptyTree" else "Thicket(" + trees.mkString(", ") + ")"
     override def withPos(pos: Position): this.type = {
       val newTrees = trees.mapConserve(_.withPos(pos))
       if (trees eq newTrees)
@@ -801,7 +797,7 @@ object Trees {
       else
         new Thicket[T](newTrees).asInstanceOf[this.type]
     }
-    override def pos = (NoPosition /: trees) ((pos, t) => pos union t.pos)
+    override def pos: Position = (NoPosition /: trees) ((pos, t) => pos union t.pos)
     override def foreachInThicket(op: Tree[T] => Unit): Unit =
       trees foreach (_.foreachInThicket(op))
   }
@@ -814,7 +810,7 @@ object Trees {
   }
 
   @sharable val theEmptyTree: Thicket[Type] = Thicket(Nil)
-  @sharable val theEmptyValDef = new EmptyValDef[Type]
+  @sharable val theEmptyValDef: EmptyValDef[Type] = new EmptyValDef[Type]
 
   def genericEmptyValDef[T >: Untyped]: ValDef[T]       = theEmptyValDef.asInstanceOf[ValDef[T]]
   def genericEmptyTree[T >: Untyped]: Thicket[T]        = theEmptyTree.asInstanceOf[Thicket[T]]
@@ -985,7 +981,7 @@ object Trees {
         case _ => finalize(tree, untpd.Select(qualifier, name))
       }
       /** Copy Ident or Select trees */
-      def Ref(tree: RefTree)(name: Name)(implicit ctx: Context) = tree match {
+      def Ref(tree: RefTree)(name: Name)(implicit ctx: Context): RefTree = tree match {
         case Ident(_) => Ident(tree)(name)
         case Select(qual, _) => Select(tree)(qual, name)
       }
@@ -1428,8 +1424,8 @@ object Trees {
 
     abstract class TreeTraverser extends TreeAccumulator[Unit] {
       def traverse(tree: Tree)(implicit ctx: Context): Unit
-      def apply(x: Unit, tree: Tree)(implicit ctx: Context) = traverse(tree)
-      protected def traverseChildren(tree: Tree)(implicit ctx: Context) = foldOver((), tree)
+      def apply(x: Unit, tree: Tree)(implicit ctx: Context): Unit = traverse(tree)
+      protected def traverseChildren(tree: Tree)(implicit ctx: Context): Unit = foldOver((), tree)
     }
 
     /** Fold `f` over all tree nodes, in depth-first, prefix order */
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 471350ba3d03..c7007294b7c8 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -8,11 +8,10 @@ import transform.SymUtils._
 import transform.TypeUtils._
 import core._
 import util.Positions._, Types._, Contexts._, Constants._, Names._, Flags._, NameOps._
-import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._, Symbols._
-import Denotations._, Decorators._, DenotTransformers._
+import Symbols._, StdNames._, Annotations._, Trees._, Symbols._
+import Decorators._, DenotTransformers._
 import collection.mutable
 import util.{Property, SourceFile, NoSource}
-import typer.ErrorReporting._
 import NameKinds.{TempResultName, OuterSelectName}
 
 import scala.annotation.tailrec
@@ -335,7 +334,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
   // ------ Making references ------------------------------------------------------
 
-  def prefixIsElidable(tp: NamedType)(implicit ctx: Context) = {
+  def prefixIsElidable(tp: NamedType)(implicit ctx: Context): Boolean = {
     val typeIsElidable = tp.prefix match {
       case pre: ThisType =>
         tp.isType ||
@@ -354,7 +353,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     tp.symbol.hasAnnotation(defn.ScalaStaticAnnot)
   }
 
-  def needsSelect(tp: Type)(implicit ctx: Context) = tp match {
+  def needsSelect(tp: Type)(implicit ctx: Context): Boolean = tp match {
     case tp: TermRef => !prefixIsElidable(tp)
     case _ => false
   }
@@ -478,9 +477,9 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   }
 
   /** A `_' with given type */
-  def Underscore(tp: Type)(implicit ctx: Context) = untpd.Ident(nme.WILDCARD).withType(tp)
+  def Underscore(tp: Type)(implicit ctx: Context): Ident = untpd.Ident(nme.WILDCARD).withType(tp)
 
-  def defaultValue(tpe: Types.Type)(implicit ctx: Context) = {
+  def defaultValue(tpe: Type)(implicit ctx: Context): Tree = {
     val tpw = tpe.widen
 
     if (tpw isRef defn.IntClass) Literal(Constant(0))
@@ -508,7 +507,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   override val cpy: TypedTreeCopier = // Type ascription needed to pick up any new members in TreeCopier (currently there are none)
     new TypedTreeCopier
 
-  val cpyBetweenPhases = new TimeTravellingTreeCopier
+  val cpyBetweenPhases: TimeTravellingTreeCopier = new TimeTravellingTreeCopier
 
   class TypedTreeCopier extends TreeCopier {
     def postProcess(tree: Tree, copied: untpd.Tree): copied.ThisTree[Type] =
@@ -678,14 +677,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       Closure(tree: Tree)(env, meth, tpt)
   }
 
-  override def skipTransform(tree: Tree)(implicit ctx: Context) = tree.tpe.isError
+  override def skipTransform(tree: Tree)(implicit ctx: Context): Boolean = tree.tpe.isError
 
   implicit class TreeOps[ThisTree <: tpd.Tree](private val tree: ThisTree) extends AnyVal {
 
     def isValue(implicit ctx: Context): Boolean =
       tree.isTerm && tree.tpe.widen.isValueType
 
-    def isValueOrPattern(implicit ctx: Context) =
+    def isValueOrPattern(implicit ctx: Context): Boolean =
       tree.isValue || tree.isPattern
 
     def isValueType: Boolean =
@@ -696,10 +695,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       case _ => false
     }
 
-    def shallowFold[T](z: T)(op: (T, tpd.Tree) => T)(implicit ctx: Context) =
+    def shallowFold[T](z: T)(op: (T, tpd.Tree) => T)(implicit ctx: Context): T =
       new ShallowFolder(op).apply(z, tree)
 
-    def deepFold[T](z: T)(op: (T, tpd.Tree) => T)(implicit ctx: Context) =
+    def deepFold[T](z: T)(op: (T, tpd.Tree) => T)(implicit ctx: Context): T =
       new DeepFolder(op).apply(z, tree)
 
     def find[T](pred: (tpd.Tree) => Boolean)(implicit ctx: Context): Option[tpd.Tree] =
@@ -827,7 +826,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       if (tree.tpe.widen.isParameterless) tree else tree.appliedToNone
 
     /** `tree == that` */
-    def equal(that: Tree)(implicit ctx: Context) =
+    def equal(that: Tree)(implicit ctx: Context): Tree =
       if (that.tpe.widen.isRef(defn.NothingClass))
         Literal(Constant(false))
       else
@@ -867,7 +866,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     /** If inititializer tree is `_', the default value of its type,
      *  otherwise the tree itself.
      */
-    def wildcardToDefault(implicit ctx: Context) =
+    def wildcardToDefault(implicit ctx: Context): Tree =
       if (isWildcardArg(tree)) defaultValue(tree.tpe) else tree
 
     /** `this && that`, for boolean trees `this`, `that` */
@@ -978,7 +977,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       rootTrees.headOption.getOrElse(EmptyTree)
 
     /** Is it possible that the tree to load contains a definition of or reference to `id`? */
-    def mightContain(id: String)(implicit ctx: Context) = true
+    def mightContain(id: String)(implicit ctx: Context): Boolean = true
   }
 
   // convert a numeric with a toXXX method
@@ -1062,7 +1061,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
    *
    *     ~within('tree)
    */
-  def letBindUnless(level: TreeInfo.PurityLevel, tree: Tree)(within: Tree => Tree)(implicit ctx: Context) = {
+  def letBindUnless(level: TreeInfo.PurityLevel, tree: Tree)(within: Tree => Tree)(implicit ctx: Context): Tree = {
     if (exprPurity(tree) >= level) within(tree)
     else {
       val vdef = SyntheticValDef(TempResultName.fresh(), tree)
@@ -1071,7 +1070,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   }
 
   /** Let bind `tree` unless `tree` is at least idempotent */
-  def evalOnce(tree: Tree)(within: Tree => Tree)(implicit ctx: Context) =
+  def evalOnce(tree: Tree)(within: Tree => Tree)(implicit ctx: Context): Tree =
     letBindUnless(TreeInfo.Idempotent, tree)(within)
 
   def runtimeCall(name: TermName, args: List[Tree])(implicit ctx: Context): Tree = {
@@ -1113,7 +1112,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   /** The source file where the symbol of the `inline` method referred to by `call`
    *  is defined
    */
-  def sourceFile(call: Tree)(implicit ctx: Context) = {
+  def sourceFile(call: Tree)(implicit ctx: Context): SourceFile = {
     val file = call.symbol.sourceFile
     val encoding = ctx.settings.encoding.value
     if (file != null && file.exists) new SourceFile(file, Codec(encoding)) else NoSource
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index 054e4e604749..7b0e6b41e23a 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -3,13 +3,10 @@ package dotc
 package ast
 
 import core._
-import util.Positions._, Types._, Contexts._, Constants._, Names._, NameOps._, Flags._
-import Denotations._, SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._
-import Decorators._
+import Types._, Contexts._, Constants._, Names._, Flags._
+import Symbols._, StdNames._, Trees._
 import util.Property
 import language.higherKinds
-import collection.mutable.ListBuffer
-import reflect.ClassTag
 
 import scala.annotation.internal.sharable
 
@@ -19,15 +16,15 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
   trait OpTree extends Tree {
     def op: Ident
-    override def isTerm = op.name.isTermName
-    override def isType = op.name.isTypeName
+    override def isTerm: Boolean = op.name.isTermName
+    override def isType: Boolean = op.name.isTypeName
   }
 
   /** A typed subtree of an untyped tree needs to be wrapped in a TypedSplice
    *  @param owner  The current owner at the time the tree was defined
    */
   abstract case class TypedSplice(splice: tpd.Tree)(val owner: Symbol) extends ProxyTree {
-    def forwardTo = splice
+    def forwardTo: tpd.Tree = splice
   }
 
   object TypedSplice {
@@ -39,7 +36,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class ModuleDef(name: TermName, impl: Template)
     extends MemberDef {
     type ThisTree[-T >: Untyped] <: Trees.NameTree[T] with Trees.MemberDef[T] with ModuleDef
-    def withName(name: Name)(implicit ctx: Context) = cpy.ModuleDef(this)(name.toTermName, impl)
+    def withName(name: Name)(implicit ctx: Context): ModuleDef = cpy.ModuleDef(this)(name.toTermName, impl)
   }
 
   case class ParsedTry(expr: Tree, handler: Tree, finalizer: Tree) extends TermTree
@@ -54,8 +51,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
   /** A function type */
   case class Function(args: List[Tree], body: Tree) extends Tree {
-    override def isTerm = body.isTerm
-    override def isType = body.isType
+    override def isTerm: Boolean = body.isTerm
+    override def isType: Boolean = body.isType
   }
 
   /** A function type with `implicit` or `erased` modifiers */
@@ -73,15 +70,15 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class InfixOp(left: Tree, op: Ident, right: Tree) extends OpTree
   case class PostfixOp(od: Tree, op: Ident) extends OpTree
   case class PrefixOp(op: Ident, od: Tree) extends OpTree {
-    override def isType = op.isType
-    override def isTerm = op.isTerm
+    override def isType: Boolean = op.isType
+    override def isTerm: Boolean = op.isTerm
   }
   case class Parens(t: Tree) extends ProxyTree {
-    def forwardTo = t
+    def forwardTo: Tree = t
   }
   case class Tuple(trees: List[Tree]) extends Tree {
-    override def isTerm = trees.isEmpty || trees.head.isTerm
-    override def isType = !isTerm
+    override def isTerm: Boolean = trees.isEmpty || trees.head.isTerm
+    override def isType: Boolean = !isTerm
   }
   case class Throw(expr: Tree) extends TermTree
   case class Quote(expr: Tree) extends TermTree
@@ -95,7 +92,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   case class DependentTypeTree(tp: List[Symbol] => Type) extends Tree
 
   @sharable object EmptyTypeIdent extends Ident(tpnme.EMPTY) with WithoutTypeOrPos[Untyped] {
-    override def isEmpty = true
+    override def isEmpty: Boolean = true
   }
 
   /** A block generated by the XML parser, only treated specially by
@@ -160,7 +157,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     def toTypeFlags: Modifiers = withFlags(flags.toTypeFlags)
     def toTermFlags: Modifiers = withFlags(flags.toTermFlags)
 
-    def withFlags(flags: FlagSet) =
+    def withFlags(flags: FlagSet): Modifiers =
       if (this.flags == flags) this
       else copy(flags = flags)
 
@@ -191,18 +188,18 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       if (annots eq annotations) this
       else copy(annotations = annots)
 
-    def withPrivateWithin(pw: TypeName) =
+    def withPrivateWithin(pw: TypeName): Modifiers =
       if (pw.isEmpty) this
       else copy(privateWithin = pw)
 
-    def hasFlags = flags != EmptyFlags
-    def hasAnnotations = annotations.nonEmpty
-    def hasPrivateWithin = privateWithin != tpnme.EMPTY
+    def hasFlags: Boolean = flags != EmptyFlags
+    def hasAnnotations: Boolean = annotations.nonEmpty
+    def hasPrivateWithin: Boolean = privateWithin != tpnme.EMPTY
 
     private def isEnum = is(Enum, butNot = JavaDefined)
 
-    def isEnumCase = isEnum && is(Case)
-    def isEnumClass = isEnum && !is(Case)
+    def isEnumCase: Boolean = isEnum && is(Case)
+    def isEnumClass: Boolean = isEnum && !is(Case)
   }
 
   @sharable val EmptyModifiers: Modifiers = new Modifiers()
@@ -246,13 +243,13 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
    *  from the symbol in this type. These type trees have marker trees
    *  TypeRefOfSym or InfoOfSym as their originals.
    */
-  val References = new Property.Key[List[DerivedTypeTree]]
+  val References: Property.Key[List[DerivedTypeTree]] = new Property.Key
 
   /** Property key for TypeTrees marked with TypeRefOfSym or InfoOfSym
    *  which contains the symbol of the original tree from which this
    *  TypeTree is derived.
    */
-  val OriginalSymbol = new Property.Key[Symbol]
+  val OriginalSymbol: Property.Key[Symbol] = new Property.Key
 
   // ------ Creation methods for untyped only -----------------
 
@@ -282,7 +279,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def SeqLiteral(elems: List[Tree], elemtpt: Tree): SeqLiteral = new SeqLiteral(elems, elemtpt)
   def JavaSeqLiteral(elems: List[Tree], elemtpt: Tree): JavaSeqLiteral = new JavaSeqLiteral(elems, elemtpt)
   def Inlined(call: tpd.Tree, bindings: List[MemberDef], expansion: Tree): Inlined = new Inlined(call, bindings, expansion)
-  def TypeTree() = new TypeTree()
+  def TypeTree(): TypeTree = new TypeTree()
   def SingletonTypeTree(ref: Tree): SingletonTypeTree = new SingletonTypeTree(ref)
   def AndTypeTree(left: Tree, right: Tree): AndTypeTree = new AndTypeTree(left, right)
   def OrTypeTree(left: Tree, right: Tree): OrTypeTree = new OrTypeTree(left, right)
@@ -299,7 +296,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def DefDef(name: TermName, tparams: List[TypeDef], vparamss: List[List[ValDef]], tpt: Tree, rhs: LazyTree): DefDef = new DefDef(name, tparams, vparamss, tpt, rhs)
   def TypeDef(name: TypeName, rhs: Tree): TypeDef = new TypeDef(name, rhs)
   def Template(constr: DefDef, parents: List[Tree], self: ValDef, body: LazyTreeList): Template = new Template(constr, parents, self, body)
-  def Import(expr: Tree, selectors: List[untpd.Tree]): Import = new Import(expr, selectors)
+  def Import(expr: Tree, selectors: List[Tree]): Import = new Import(expr, selectors)
   def PackageDef(pid: RefTree, stats: List[Tree]): PackageDef = new PackageDef(pid, stats)
   def Annotated(arg: Tree, annot: Tree): Annotated = new Annotated(arg, annot)
 
@@ -336,7 +333,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def Apply(fn: Tree, arg: Tree): Apply =
     Apply(fn, arg :: Nil)
 
-  def ensureApplied(tpt: Tree) = tpt match {
+  def ensureApplied(tpt: Tree): Tree = tpt match {
     case _: Apply => tpt
     case _ => Apply(tpt, Nil)
   }
@@ -346,15 +343,15 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
   def TypeTree(tpe: Type)(implicit ctx: Context): TypedSplice = TypedSplice(TypeTree().withTypeUnchecked(tpe))
 
-  def unitLiteral = Literal(Constant(()))
+  def unitLiteral: Literal = Literal(Constant(()))
 
   def ref(tp: NamedType)(implicit ctx: Context): Tree =
     TypedSplice(tpd.ref(tp))
 
-  def rootDot(name: Name) = Select(Ident(nme.ROOTPKG), name)
-  def scalaDot(name: Name) = Select(rootDot(nme.scala_), name)
-  def scalaUnit = scalaDot(tpnme.Unit)
-  def scalaAny = scalaDot(tpnme.Any)
+  def rootDot(name: Name): Select = Select(Ident(nme.ROOTPKG), name)
+  def scalaDot(name: Name): Select = Select(rootDot(nme.scala_), name)
+  def scalaUnit: Select = scalaDot(tpnme.Unit)
+  def scalaAny: Select = scalaDot(tpnme.Any)
 
   def makeConstructor(tparams: List[TypeDef], vparamss: List[List[ValDef]], rhs: Tree = EmptyTree)(implicit ctx: Context): DefDef =
     DefDef(nme.CONSTRUCTOR, tparams, vparamss, TypeTree(), rhs)
@@ -362,15 +359,15 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def emptyConstructor(implicit ctx: Context): DefDef =
     makeConstructor(Nil, Nil)
 
-  def makeSelfDef(name: TermName, tpt: Tree)(implicit ctx: Context) =
+  def makeSelfDef(name: TermName, tpt: Tree)(implicit ctx: Context): ValDef =
     ValDef(name, tpt, EmptyTree).withFlags(PrivateLocal)
 
-  def makeTupleOrParens(ts: List[Tree])(implicit ctx: Context) = ts match {
+  def makeTupleOrParens(ts: List[Tree])(implicit ctx: Context): Tree = ts match {
     case t :: Nil => Parens(t)
     case _ => Tuple(ts)
   }
 
-  def makeTuple(ts: List[Tree])(implicit ctx: Context) = ts match {
+  def makeTuple(ts: List[Tree])(implicit ctx: Context): Tree = ts match {
     case t :: Nil => t
     case _ => Tuple(ts)
   }
@@ -381,26 +378,26 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def makeSyntheticParameter(n: Int = 1, tpt: Tree = TypeTree())(implicit ctx: Context): ValDef =
     ValDef(nme.syntheticParamName(n), tpt, EmptyTree).withFlags(SyntheticTermParam)
 
-  def lambdaAbstract(tparams: List[TypeDef], tpt: Tree)(implicit ctx: Context) =
+  def lambdaAbstract(tparams: List[TypeDef], tpt: Tree)(implicit ctx: Context): Tree =
     if (tparams.isEmpty) tpt else LambdaTypeTree(tparams, tpt)
 
   /** A reference to given definition. If definition is a repeated
    *  parameter, the reference will be a repeated argument.
    */
-  def refOfDef(tree: MemberDef)(implicit ctx: Context) = tree match {
+  def refOfDef(tree: MemberDef)(implicit ctx: Context): Tree = tree match {
     case ValDef(_, PostfixOp(_, Ident(tpnme.raw.STAR)), _) => repeated(Ident(tree.name))
     case _ => Ident(tree.name)
   }
 
   /** A repeated argument such as `arg: _*` */
-  def repeated(arg: Tree)(implicit ctx: Context) = Typed(arg, Ident(tpnme.WILDCARD_STAR))
+  def repeated(arg: Tree)(implicit ctx: Context): Typed = 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
+    def mods: Modifiers = mdef.rawMods
   }
 
 // --------- Copier/Transformer/Accumulator classes for untyped trees -----
@@ -419,84 +416,84 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       }
     }.asInstanceOf[copied.ThisTree[Untyped]]
 
-    def ModuleDef(tree: Tree)(name: TermName, impl: Template) = tree match {
+    def ModuleDef(tree: Tree)(name: TermName, impl: Template): ModuleDef = tree match {
       case tree: ModuleDef if (name eq tree.name) && (impl eq tree.impl) => tree
       case _ => finalize(tree, untpd.ModuleDef(name, impl))
     }
-    def ParsedTry(tree: Tree)(expr: Tree, handler: Tree, finalizer: Tree) = tree match {
+    def ParsedTry(tree: Tree)(expr: Tree, handler: Tree, finalizer: Tree): TermTree = tree match {
       case tree: ParsedTry
         if (expr eq tree.expr) && (handler eq tree.handler) && (finalizer eq tree.finalizer) => tree
       case _ => finalize(tree, untpd.ParsedTry(expr, handler, finalizer))
     }
-    def SymbolLit(tree: Tree)(str: String) = tree match {
+    def SymbolLit(tree: Tree)(str: String): TermTree = tree match {
       case tree: SymbolLit if str == tree.str => tree
       case _ => finalize(tree, untpd.SymbolLit(str))
     }
-    def InterpolatedString(tree: Tree)(id: TermName, segments: List[Tree]) = tree match {
+    def InterpolatedString(tree: Tree)(id: TermName, segments: List[Tree]): TermTree = tree match {
       case tree: InterpolatedString if (id eq tree.id) && (segments eq tree.segments) => tree
       case _ => finalize(tree, untpd.InterpolatedString(id, segments))
     }
-    def Function(tree: Tree)(args: List[Tree], body: Tree) = tree match {
+    def Function(tree: Tree)(args: List[Tree], body: Tree): Tree = tree match {
       case tree: Function if (args eq tree.args) && (body eq tree.body) => tree
       case _ => finalize(tree, untpd.Function(args, body))
     }
-    def InfixOp(tree: Tree)(left: Tree, op: Ident, right: Tree) = tree match {
+    def InfixOp(tree: Tree)(left: Tree, op: Ident, right: Tree): Tree = tree match {
       case tree: InfixOp if (left eq tree.left) && (op eq tree.op) && (right eq tree.right) => tree
       case _ => finalize(tree, untpd.InfixOp(left, op, right))
     }
-    def PostfixOp(tree: Tree)(od: Tree, op: Ident) = tree match {
+    def PostfixOp(tree: Tree)(od: Tree, op: Ident): Tree = tree match {
       case tree: PostfixOp if (od eq tree.od) && (op eq tree.op) => tree
       case _ => finalize(tree, untpd.PostfixOp(od, op))
     }
-    def PrefixOp(tree: Tree)(op: Ident, od: Tree) = tree match {
+    def PrefixOp(tree: Tree)(op: Ident, od: Tree): Tree = tree match {
       case tree: PrefixOp if (op eq tree.op) && (od eq tree.od) => tree
       case _ => finalize(tree, untpd.PrefixOp(op, od))
     }
-    def Parens(tree: Tree)(t: Tree) = tree match {
+    def Parens(tree: Tree)(t: Tree): ProxyTree = tree match {
       case tree: Parens if t eq tree.t => tree
       case _ => finalize(tree, untpd.Parens(t))
     }
-    def Tuple(tree: Tree)(trees: List[Tree]) = tree match {
+    def Tuple(tree: Tree)(trees: List[Tree]): Tree = tree match {
       case tree: Tuple if trees eq tree.trees => tree
       case _ => finalize(tree, untpd.Tuple(trees))
     }
-    def Throw(tree: Tree)(expr: Tree) = tree match {
+    def Throw(tree: Tree)(expr: Tree): TermTree = tree match {
       case tree: Throw if expr eq tree.expr => tree
       case _ => finalize(tree, untpd.Throw(expr))
     }
-    def Quote(tree: Tree)(expr: Tree) = tree match {
+    def Quote(tree: Tree)(expr: Tree): TermTree = tree match {
       case tree: Quote if expr eq tree.expr => tree
       case _ => finalize(tree, untpd.Quote(expr))
     }
-    def DoWhile(tree: Tree)(body: Tree, cond: Tree) = tree match {
+    def DoWhile(tree: Tree)(body: Tree, cond: Tree): TermTree = tree match {
       case tree: DoWhile if (body eq tree.body) && (cond eq tree.cond) => tree
       case _ => finalize(tree, untpd.DoWhile(body, cond))
     }
-    def ForYield(tree: Tree)(enums: List[Tree], expr: Tree) = tree match {
+    def ForYield(tree: Tree)(enums: List[Tree], expr: Tree): TermTree = tree match {
       case tree: ForYield if (enums eq tree.enums) && (expr eq tree.expr) => tree
       case _ => finalize(tree, untpd.ForYield(enums, expr))
     }
-    def ForDo(tree: Tree)(enums: List[Tree], body: Tree) = tree match {
+    def ForDo(tree: Tree)(enums: List[Tree], body: Tree): TermTree = tree match {
       case tree: ForDo if (enums eq tree.enums) && (body eq tree.body) => tree
       case _ => finalize(tree, untpd.ForDo(enums, body))
     }
-    def GenFrom(tree: Tree)(pat: Tree, expr: Tree) = tree match {
+    def GenFrom(tree: Tree)(pat: Tree, expr: Tree): Tree = tree match {
       case tree: GenFrom if (pat eq tree.pat) && (expr eq tree.expr) => tree
       case _ => finalize(tree, untpd.GenFrom(pat, expr))
     }
-    def GenAlias(tree: Tree)(pat: Tree, expr: Tree) = tree match {
+    def GenAlias(tree: Tree)(pat: Tree, expr: Tree): Tree = tree match {
       case tree: GenAlias if (pat eq tree.pat) && (expr eq tree.expr) => tree
       case _ => finalize(tree, untpd.GenAlias(pat, expr))
     }
-    def ContextBounds(tree: Tree)(bounds: TypeBoundsTree, cxBounds: List[Tree]) = tree match {
+    def ContextBounds(tree: Tree)(bounds: TypeBoundsTree, cxBounds: List[Tree]): TypTree = tree match {
       case tree: ContextBounds if (bounds eq tree.bounds) && (cxBounds eq tree.cxBounds) => tree
       case _ => finalize(tree, untpd.ContextBounds(bounds, cxBounds))
     }
-    def PatDef(tree: Tree)(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree) = tree match {
+    def PatDef(tree: Tree)(mods: Modifiers, pats: List[Tree], tpt: Tree, rhs: Tree): Tree = tree match {
       case tree: PatDef if (mods eq tree.mods) && (pats eq tree.pats) && (tpt eq tree.tpt) && (rhs eq tree.rhs) => tree
       case _ => finalize(tree, untpd.PatDef(mods, pats, tpt, rhs))
     }
-    def TypedSplice(tree: Tree)(splice: tpd.Tree)(implicit ctx: Context) = tree match {
+    def TypedSplice(tree: Tree)(splice: tpd.Tree)(implicit ctx: Context): ProxyTree = tree match {
       case tree: TypedSplice if splice `eq` tree.splice => tree
       case _ => finalize(tree, untpd.TypedSplice(splice))
     }
@@ -598,8 +595,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
 
   abstract class UntypedTreeTraverser extends UntypedTreeAccumulator[Unit] {
     def traverse(tree: Tree)(implicit ctx: Context): Unit
-    def apply(x: Unit, tree: Tree)(implicit ctx: Context) = traverse(tree)
-    protected def traverseChildren(tree: Tree)(implicit ctx: Context) = foldOver((), tree)
+    def apply(x: Unit, tree: Tree)(implicit ctx: Context): Unit = traverse(tree)
+    protected def traverseChildren(tree: Tree)(implicit ctx: Context): Unit = foldOver((), tree)
   }
 
   /** Fold `f` over all tree nodes, in depth-first, prefix order */
diff --git a/compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala
index 227282ff9ebd..24cd2e4d632b 100644
--- a/compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala
+++ b/compiler/src/dotty/tools/dotc/classpath/AggregateClassPath.scala
@@ -5,7 +5,6 @@ package dotty.tools
 package dotc.classpath
 
 import java.net.URL
-import scala.annotation.tailrec
 import scala.collection.mutable.ArrayBuffer
 import dotty.tools.io.{ AbstractFile, ClassPath, ClassRepresentation }
 
@@ -66,7 +65,7 @@ case class AggregateClassPath(aggregates: Seq[ClassPath]) extends ClassPath {
   override private[dotty] def sources(inPackage: String): Seq[SourceFileEntry] =
     getDistinctEntries(_.sources(inPackage))
 
-  override private[dotty] def hasPackage(pkg: String) = aggregates.exists(_.hasPackage(pkg))
+  override private[dotty] def hasPackage(pkg: String): Boolean = aggregates.exists(_.hasPackage(pkg))
   override private[dotty] def list(inPackage: String): ClassPathEntries = {
     val (packages, classesAndSources) = aggregates.map { cp =>
       try {
diff --git a/compiler/src/dotty/tools/dotc/classpath/ClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/ClassPath.scala
index 06a465530db3..6895897989d0 100644
--- a/compiler/src/dotty/tools/dotc/classpath/ClassPath.scala
+++ b/compiler/src/dotty/tools/dotc/classpath/ClassPath.scala
@@ -7,7 +7,7 @@ import dotty.tools.io.AbstractFile
 import dotty.tools.io.ClassRepresentation
 
 case class ClassPathEntries(packages: Seq[PackageEntry], classesAndSources: Seq[ClassRepresentation]) {
-  def toTuple = (packages, classesAndSources)
+  def toTuple: (Seq[PackageEntry], Seq[ClassRepresentation]) = (packages, classesAndSources)
 }
 
 trait ClassFileEntry extends ClassRepresentation {
@@ -23,21 +23,21 @@ trait PackageEntry {
 }
 
 private[dotty] case class ClassFileEntryImpl(file: AbstractFile) extends ClassFileEntry {
-  override def name = FileUtils.stripClassExtension(file.name) // class name
+  override def name: String = FileUtils.stripClassExtension(file.name) // class name
 
   override def binary: Option[AbstractFile] = Some(file)
   override def source: Option[AbstractFile] = None
 }
 
 private[dotty] case class SourceFileEntryImpl(file: AbstractFile) extends SourceFileEntry {
-  override def name = FileUtils.stripSourceExtension(file.name)
+  override def name: String = FileUtils.stripSourceExtension(file.name)
 
   override def binary: Option[AbstractFile] = None
   override def source: Option[AbstractFile] = Some(file)
 }
 
 private[dotty] case class ClassAndSourceFilesEntry(classFile: AbstractFile, srcFile: AbstractFile) extends ClassRepresentation {
-  override def name = FileUtils.stripClassExtension(classFile.name)
+  override def name: String = FileUtils.stripClassExtension(classFile.name)
 
   override def binary: Option[AbstractFile] = Some(classFile)
   override def source: Option[AbstractFile] = Some(srcFile)
diff --git a/compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala b/compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala
index fffbeac83116..3ade2fcf2f13 100644
--- a/compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala
+++ b/compiler/src/dotty/tools/dotc/classpath/ClassPathFactory.scala
@@ -4,7 +4,6 @@
 package dotty.tools.dotc.classpath
 
 import dotty.tools.io.{AbstractFile, VirtualDirectory}
-import dotty.tools.dotc.config.Settings
 import FileUtils.AbstractFileOps
 import dotty.tools.io.ClassPath
 import dotty.tools.dotc.core.Contexts.Context
@@ -43,14 +42,14 @@ class ClassPathFactory {
   def classesInExpandedPath(path: String)(implicit ctx: Context): IndexedSeq[ClassPath] =
     classesInPathImpl(path, expand = true).toIndexedSeq
 
-  def classesInPath(path: String)(implicit ctx: Context) = classesInPathImpl(path, expand = false)
+  def classesInPath(path: String)(implicit ctx: Context): List[ClassPath] = classesInPathImpl(path, expand = false)
 
-  def classesInManifest(useManifestClassPath: Boolean)(implicit ctx: Context) =
+  def classesInManifest(useManifestClassPath: Boolean)(implicit ctx: Context): List[ClassPath] =
     if (useManifestClassPath) dotty.tools.io.ClassPath.manifests.map(url => newClassPath(AbstractFile getResources url))
     else Nil
 
   // Internal
-  protected def classesInPathImpl(path: String, expand: Boolean)(implicit ctx: Context) =
+  protected def classesInPathImpl(path: String, expand: Boolean)(implicit ctx: Context): List[ClassPath] =
     for {
       file <- expandPath(path, expand)
       dir <- {
diff --git a/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala
index 5e18859bae8d..a761d746efdd 100644
--- a/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala
+++ b/compiler/src/dotty/tools/dotc/classpath/DirectoryClassPath.scala
@@ -4,11 +4,8 @@
 package dotty.tools.dotc.classpath
 
 import java.io.{File => JFile}
-import java.net.{URI, URL}
-import java.nio.file.{FileSystems, Files, SimpleFileVisitor}
-import java.util.function.IntFunction
-import java.util
-import java.util.Comparator
+import java.net.URL
+import java.nio.file.{FileSystems, Files}
 
 import dotty.tools.io.{AbstractFile, PlainFile, ClassPath, ClassRepresentation}
 import FileUtils._
@@ -45,7 +42,7 @@ trait DirectoryLookup[FileEntryType <: ClassRepresentation] extends ClassPath {
     }
   }
 
-  override private[dotty] def hasPackage(pkg: String) = getDirectory(pkg).isDefined
+  override private[dotty] def hasPackage(pkg: String): Boolean = getDirectory(pkg).isDefined
 
   private[dotty] def packages(inPackage: String): Seq[PackageEntry] = {
     val dirForPackage = getDirectory(inPackage)
@@ -164,7 +161,7 @@ final class JrtClassPath(fs: java.nio.file.FileSystem) extends ClassPath with No
   }
 
   /** Empty string represents root package */
-  override private[dotty] def hasPackage(pkg: String) = packageToModuleBases.contains(pkg)
+  override private[dotty] def hasPackage(pkg: String): Boolean = packageToModuleBases.contains(pkg)
 
   override private[dotty] def packages(inPackage: String): Seq[PackageEntry] = {
     def matches(packageDottedName: String) =
diff --git a/compiler/src/dotty/tools/dotc/classpath/FileUtils.scala b/compiler/src/dotty/tools/dotc/classpath/FileUtils.scala
index ef571dbbf4b5..684fc7a58239 100644
--- a/compiler/src/dotty/tools/dotc/classpath/FileUtils.scala
+++ b/compiler/src/dotty/tools/dotc/classpath/FileUtils.scala
@@ -43,7 +43,7 @@ object FileUtils {
     else throw new FatalError("Unexpected source file ending: " + fileName)
   }
 
-  def dirPath(forPackage: String) = forPackage.replace('.', '/')
+  def dirPath(forPackage: String): String = forPackage.replace('.', '/')
 
   def endsClass(fileName: String): Boolean =
     fileName.length > 6 && fileName.substring(fileName.length - 6) == ".class"
@@ -68,7 +68,7 @@ object FileUtils {
   def mayBeValidPackage(dirName: String): Boolean =
     (dirName != "META-INF") && (dirName != "") && (dirName.charAt(0) != '.')
 
-  def mkFileFilter(f: JFile => Boolean) = new FileFilter {
+  def mkFileFilter(f: JFile => Boolean): FileFilter = new FileFilter {
     def accept(pathname: JFile): Boolean = f(pathname)
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala b/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala
index 51a97ef7ac14..1579e70afc55 100644
--- a/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala
+++ b/compiler/src/dotty/tools/dotc/classpath/VirtualDirectoryClassPath.scala
@@ -1,7 +1,7 @@
 package dotty.tools.dotc.classpath
 
 import dotty.tools.io.ClassRepresentation
-import dotty.tools.io.{AbstractFile, Path, PlainFile, VirtualDirectory}
+import dotty.tools.io.{AbstractFile, VirtualDirectory}
 import FileUtils._
 import java.net.URL
 
diff --git a/compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala b/compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala
index 77f628c673d4..256956fdb54b 100644
--- a/compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala
+++ b/compiler/src/dotty/tools/dotc/classpath/ZipArchiveFileLookup.scala
@@ -46,7 +46,7 @@ trait ZipArchiveFileLookup[FileEntryType <: ClassRepresentation] extends ClassPa
       if isRequiredFileType(entry)
     } yield createFileEntry(entry)
 
-  override private[dotty] def hasPackage(pkg: String) = findDirEntry(pkg).isDefined
+  override private[dotty] def hasPackage(pkg: String): Boolean = findDirEntry(pkg).isDefined
   override private[dotty] def list(inPackage: String): ClassPathEntries = {
     val foundDirEntry = findDirEntry(inPackage)
 
diff --git a/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala b/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala
index 81b4bdade5bf..c99724b4d024 100644
--- a/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala
+++ b/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala
@@ -5,7 +5,6 @@ import java.nio.file.{Files, Paths}
 
 import Settings._
 import core.Contexts._
-import util.DotClass
 import Properties._
 
 import scala.collection.JavaConverters._
@@ -13,7 +12,7 @@ import scala.collection.JavaConverters._
 object CompilerCommand {
 
   /** The name of the command */
-  def cmdName = "dotc"
+  def cmdName: String = "dotc"
 
   private def explainAdvanced = """
     |-- Notes on option parsing --
@@ -30,9 +29,9 @@ object CompilerCommand {
     |           already are in phase X + 1.
   """
 
-  def shortUsage = s"Usage: $cmdName <options> <source files>"
+  def shortUsage: String = s"Usage: $cmdName <options> <source files>"
 
-  def versionMsg = s"Dotty compiler $versionString -- $copyrightString"
+  def versionMsg: String = s"Dotty compiler $versionString -- $copyrightString"
 
   /** Distill arguments into summary detailing settings, errors and files to compiler */
   def distill(args: Array[String])(implicit ctx: Context): ArgsSummary = {
diff --git a/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala b/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala
index f0db0deafb6d..cbcf3c703f1d 100644
--- a/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala
+++ b/compiler/src/dotty/tools/dotc/config/JavaPlatform.scala
@@ -5,8 +5,8 @@ package config
 import io._
 import classpath.AggregateClassPath
 import core._
-import Symbols._, Types._, Contexts._, Denotations._, SymDenotations._, StdNames._, Names._
-import Flags._, Scopes._, Decorators._, NameOps._, util.Positions._
+import Symbols._, Types._, Contexts._, SymDenotations._, StdNames._
+import Flags._
 import transform.ExplicitOuter, transform.SymUtils._
 
 class JavaPlatform extends Platform {
@@ -21,7 +21,7 @@ class JavaPlatform extends Platform {
   }
 
   // The given symbol is a method with the right name and signature to be a runnable java program.
-  def isMainMethod(sym: SymDenotation)(implicit ctx: Context) =
+  def isMainMethod(sym: SymDenotation)(implicit ctx: Context): Boolean =
     (sym.name == nme.main) && (sym.info match {
       case MethodTpe(_, defn.ArrayOf(el) :: Nil, restpe) => el =:= defn.StringType && (restpe isRef defn.UnitClass)
       case _ => false
@@ -50,7 +50,7 @@ class JavaPlatform extends Platform {
    *  to anything but other booleans, but it should be present in
    *  case this is put to other uses.
    */
-  def isMaybeBoxed(sym: ClassSymbol)(implicit ctx: Context) = {
+  def isMaybeBoxed(sym: ClassSymbol)(implicit ctx: Context): Boolean = {
     val d = defn
     import d._
     (sym == ObjectClass) ||
diff --git a/compiler/src/dotty/tools/dotc/config/PathResolver.scala b/compiler/src/dotty/tools/dotc/config/PathResolver.scala
index cb9abd70d236..943431566aa8 100644
--- a/compiler/src/dotty/tools/dotc/config/PathResolver.scala
+++ b/compiler/src/dotty/tools/dotc/config/PathResolver.scala
@@ -2,15 +2,15 @@ package dotty.tools
 package dotc
 package config
 
-import java.net.{ URL, MalformedURLException }
 import WrappedProperties.AccessControl
-import io.{ ClassPath, File, Directory, Path, AbstractFile }
+import io.{ ClassPath, Directory, Path }
 import classpath.{AggregateClassPath, ClassPathFactory, JrtClassPath }
-import ClassPath.{ JavaContext, join, split }
+import ClassPath.split
 import PartialFunction.condOpt
 import scala.language.postfixOps
 import core.Contexts._
 import Settings._
+import dotty.tools.io.File
 
 // Loosely based on the draft specification at:
 // https://wiki.scala-lang.org/display/SW/Classpath
@@ -21,14 +21,14 @@ object PathResolver {
   // security exceptions.
   import AccessControl._
 
-  def firstNonEmpty(xs: String*) = xs find (_ != "") getOrElse ""
+  def firstNonEmpty(xs: String*): String = xs find (_ != "") getOrElse ""
 
   /** Map all classpath elements to absolute paths and reconstruct the classpath.
     */
-  def makeAbsolute(cp: String) = ClassPath.map(cp, x => Path(x).toAbsolute.path)
+  def makeAbsolute(cp: String): String = ClassPath.map(cp, x => Path(x).toAbsolute.path)
 
   /** pretty print class path */
-  def ppcp(s: String) = split(s) match {
+  def ppcp(s: String): String = split(s) match {
     case Nil      => ""
     case Seq(x)   => x
     case xs       => xs map ("\n" + _) mkString
@@ -44,20 +44,20 @@ object PathResolver {
     /** Environment variables which java pays attention to so it
      *  seems we do as well.
      */
-    def classPathEnv        =  envOrElse("CLASSPATH", "")
-    def sourcePathEnv       =  envOrElse("SOURCEPATH", "")
+    def classPathEnv: String        =  envOrElse("CLASSPATH", "")
+    def sourcePathEnv: String       =  envOrElse("SOURCEPATH", "")
 
-    def javaBootClassPath   = propOrElse("sun.boot.class.path", searchForBootClasspath)
+    def javaBootClassPath: String   = propOrElse("sun.boot.class.path", searchForBootClasspath)
 
-    def javaExtDirs         = propOrEmpty("java.ext.dirs")
-    def scalaHome           = propOrEmpty("scala.home")
-    def scalaExtDirs        = propOrEmpty("scala.ext.dirs")
+    def javaExtDirs: String         = propOrEmpty("java.ext.dirs")
+    def scalaHome: String           = propOrEmpty("scala.home")
+    def scalaExtDirs: String        = propOrEmpty("scala.ext.dirs")
 
     /** The java classpath and whether to use it. */
-    def javaUserClassPath   = propOrElse("java.class.path", "")
-    def useJavaClassPath    = propOrFalse("scala.usejavacp")
+    def javaUserClassPath: String   = propOrElse("java.class.path", "")
+    def useJavaClassPath: Boolean    = propOrFalse("scala.usejavacp")
 
-    override def toString = s"""
+    override def toString: String = s"""
       |object Environment {
       |  scalaHome          = $scalaHome (useJavaClassPath = $useJavaClassPath)
       |  javaBootClassPath  = <${javaBootClassPath.length} chars>
@@ -71,27 +71,27 @@ object PathResolver {
    *  to the path resolution specification.
    */
   object Defaults {
-    def scalaSourcePath   = Environment.sourcePathEnv
-    def javaBootClassPath = Environment.javaBootClassPath
-    def javaUserClassPath = Environment.javaUserClassPath
-    def javaExtDirs       = Environment.javaExtDirs
-    def useJavaClassPath  = Environment.useJavaClassPath
+    def scalaSourcePath: String    = Environment.sourcePathEnv
+    def javaBootClassPath: String  = Environment.javaBootClassPath
+    def javaUserClassPath: String  = Environment.javaUserClassPath
+    def javaExtDirs: String        = Environment.javaExtDirs
+    def useJavaClassPath: Boolean  = Environment.useJavaClassPath
 
-    def scalaHome         = Environment.scalaHome
-    def scalaHomeDir      = Directory(scalaHome)
-    def scalaHomeExists   = scalaHomeDir.isDirectory
-    def scalaLibDir       = (scalaHomeDir / "lib").toDirectory
-    def scalaClassesDir   = (scalaHomeDir / "classes").toDirectory
+    def scalaHome: String            = Environment.scalaHome
+    def scalaHomeDir: Directory      = Directory(scalaHome)
+    def scalaHomeExists: Boolean     = scalaHomeDir.isDirectory
+    def scalaLibDir: Directory       = (scalaHomeDir / "lib").toDirectory
+    def scalaClassesDir: Directory   = (scalaHomeDir / "classes").toDirectory
 
-    def scalaLibAsJar     = (scalaLibDir / "scala-library.jar").toFile
-    def scalaLibAsDir     = (scalaClassesDir / "library").toDirectory
+    def scalaLibAsJar: File           = (scalaLibDir / "scala-library.jar").toFile
+    def scalaLibAsDir: Directory     = (scalaClassesDir / "library").toDirectory
 
     def scalaLibDirFound: Option[Directory] =
       if (scalaLibAsJar.isFile) Some(scalaLibDir)
       else if (scalaLibAsDir.isDirectory) Some(scalaClassesDir)
       else None
 
-    def scalaLibFound =
+    def scalaLibFound: String =
       if (scalaLibAsJar.isFile) scalaLibAsJar.path
       else if (scalaLibAsDir.isDirectory) scalaLibAsDir.path
       else ""
@@ -101,7 +101,7 @@ object PathResolver {
     // the scala jars to end up on the classpath twice: one on the boot
     // classpath as set up by the runner (or regular classpath under -nobootcp)
     // and then again here.
-    def scalaBootClassPath  = ""
+    def scalaBootClassPath: String  = ""
     // scalaLibDirFound match {
     //   case Some(dir) if scalaHomeExists =>
     //     val paths = ClassPath expandDir dir.path
@@ -109,11 +109,11 @@ object PathResolver {
     //   case _                            => ""
     // }
 
-    def scalaExtDirs = Environment.scalaExtDirs
+    def scalaExtDirs: String = Environment.scalaExtDirs
 
-    def scalaPluginPath = (scalaHomeDir / "misc" / "scala-devel" / "plugins").path
+    def scalaPluginPath: String = (scalaHomeDir / "misc" / "scala-devel" / "plugins").path
 
-    override def toString = """
+    override def toString: String = """
       |object Defaults {
       |  scalaHome            = %s
       |  javaBootClassPath    = %s
@@ -159,7 +159,7 @@ object PathResolver {
     }
   }
 }
-import PathResolver.{ Defaults, Environment, firstNonEmpty, ppcp }
+import PathResolver.{ Defaults, ppcp }
 
 class PathResolver(implicit ctx: Context) {
   import ctx.base.settings
@@ -187,14 +187,14 @@ class PathResolver(implicit ctx: Context) {
    *  those in Defaults.
    */
   object Calculated {
-    def scalaHome           = Defaults.scalaHome
-    def useJavaClassPath    = settings.usejavacp.value || Defaults.useJavaClassPath
-    def javaBootClassPath   = cmdLineOrElse("javabootclasspath", Defaults.javaBootClassPath)
-    def javaExtDirs         = cmdLineOrElse("javaextdirs", Defaults.javaExtDirs)
-    def javaUserClassPath   = if (useJavaClassPath) Defaults.javaUserClassPath else ""
-    def scalaBootClassPath  = cmdLineOrElse("bootclasspath", Defaults.scalaBootClassPath)
-    def scalaExtDirs        = cmdLineOrElse("extdirs", Defaults.scalaExtDirs)
-    def priorityClassPath   = cmdLineOrElse("priorityclasspath", "")
+    def scalaHome: String           = Defaults.scalaHome
+    def useJavaClassPath: Boolean   = settings.usejavacp.value || Defaults.useJavaClassPath
+    def javaBootClassPath: String   = cmdLineOrElse("javabootclasspath", Defaults.javaBootClassPath)
+    def javaExtDirs: String         = cmdLineOrElse("javaextdirs", Defaults.javaExtDirs)
+    def javaUserClassPath: String   = if (useJavaClassPath) Defaults.javaUserClassPath else ""
+    def scalaBootClassPath: String  = cmdLineOrElse("bootclasspath", Defaults.scalaBootClassPath)
+    def scalaExtDirs: String        = cmdLineOrElse("extdirs", Defaults.scalaExtDirs)
+    def priorityClassPath: String   = cmdLineOrElse("priorityclasspath", "")
     /** Scaladoc doesn't need any bootstrapping, otherwise will create errors such as:
      * [scaladoc] ../scala-trunk/src/reflect/scala/reflect/macros/Reifiers.scala:89: error: object api is not a member of package reflect
      * [scaladoc] case class ReificationException(val pos: reflect.api.PositionApi, val msg: String) extends Throwable(msg)
@@ -203,7 +203,7 @@ class PathResolver(implicit ctx: Context) {
      * and then when typing relative names, instead of picking <root>.scala.relect, typedIdentifier will pick up the
      * <root>.reflect package created by the bootstrapping. Thus, no bootstrapping for scaladoc!
      * TODO: we should refactor this as a separate -bootstrap option to have a clean implementation, no? */
-    def sourcePath          = cmdLineOrElse("sourcepath", Defaults.scalaSourcePath)
+    def sourcePath: String          = cmdLineOrElse("sourcepath", Defaults.scalaSourcePath)
 
     /** Against my better judgment, giving in to martin here and allowing
      *  CLASSPATH to be used automatically.  So for the user-specified part
@@ -213,7 +213,7 @@ class PathResolver(implicit ctx: Context) {
      *  - Otherwise, if CLASSPATH is set, it is that
      *  - If neither of those, then "." is used.
      */
-    def userClassPath = {
+    def userClassPath: String = {
       if (!settings.classpath.isDefault)
         settings.classpath.value
       else sys.env.getOrElse("CLASSPATH", ".")
@@ -223,7 +223,7 @@ class PathResolver(implicit ctx: Context) {
 
     // Assemble the elements!
     // priority class path takes precedence
-    def basis = List[Traversable[ClassPath]](
+    def basis: List[Traversable[ClassPath]] = List(
       classesInExpandedPath(priorityClassPath),     // 0. The priority class path (for testing).
       JrtClassPath.apply(),                         // 1. The Java 9 classpath (backed by the jrt:/ virtual system, if available)
       classesInPath(javaBootClassPath),             // 2. The Java bootstrap class path.
@@ -235,9 +235,9 @@ class PathResolver(implicit ctx: Context) {
       sourcesInPath(sourcePath)                     // 8. The Scala source path.
     )
 
-    lazy val containers = basis.flatten.distinct
+    lazy val containers: List[ClassPath] = basis.flatten.distinct
 
-    override def toString = """
+    override def toString: String = """
       |object Calculated {
       |  scalaHome            = %s
       |  priorityClassPath    = %s
@@ -258,7 +258,7 @@ class PathResolver(implicit ctx: Context) {
       )
   }
 
-  def containers = Calculated.containers
+  def containers: List[ClassPath] = Calculated.containers
 
   lazy val result: ClassPath = {
     val cp = AggregateClassPath(containers.toIndexedSeq)
@@ -275,6 +275,6 @@ class PathResolver(implicit ctx: Context) {
     cp
   }
 
-  def asURLs = result.asURLs
+  def asURLs: Seq[java.net.URL] = result.asURLs
 
 }
diff --git a/compiler/src/dotty/tools/dotc/config/Properties.scala b/compiler/src/dotty/tools/dotc/config/Properties.scala
index a4523f5d4633..c025685d1801 100644
--- a/compiler/src/dotty/tools/dotc/config/Properties.scala
+++ b/compiler/src/dotty/tools/dotc/config/Properties.scala
@@ -4,17 +4,17 @@ package config
 
 import scala.annotation.internal.sharable
 
-import java.io.{ IOException, PrintWriter }
+import java.io.IOException
 import java.util.jar.Attributes.{ Name => AttributeName }
 
 /** Loads `library.properties` from the jar. */
 object Properties extends PropertiesTrait {
-  protected def propCategory    = "compiler"
-  protected def pickJarBasedOn  = classOf[Option[_]]
+  protected def propCategory: String = "compiler"
+  protected def pickJarBasedOn: Class[Option[_]] = classOf[Option[_]]
 
   /** Scala manifest attributes.
    */
-  @sharable val ScalaCompilerVersion = new AttributeName("Scala-Compiler-Version")
+  @sharable val ScalaCompilerVersion: AttributeName = new AttributeName("Scala-Compiler-Version")
 }
 
 trait PropertiesTrait {
@@ -22,7 +22,7 @@ trait PropertiesTrait {
   protected def pickJarBasedOn: Class[_]  // props file comes from jar containing this
 
   /** The name of the properties file */
-  protected val propFilename = "/" + propCategory + ".properties"
+  protected val propFilename: String = "/" + propCategory + ".properties"
 
   /** The loaded properties */
   @sharable protected lazy val scalaProps: java.util.Properties = {
@@ -41,18 +41,18 @@ trait PropertiesTrait {
         catch   { case _: IOException => }
     }
 
-  def propIsSet(name: String)                   = System.getProperty(name) != null
-  def propIsSetTo(name: String, value: String)  = propOrNull(name) == value
-  def propOrElse(name: String, alt: String)     = System.getProperty(name, alt)
-  def propOrEmpty(name: String)                 = propOrElse(name, "")
-  def propOrNull(name: String)                  = propOrElse(name, null)
-  def propOrNone(name: String)                  = Option(propOrNull(name))
-  def propOrFalse(name: String)                 = propOrNone(name) exists (x => List("yes", "on", "true") contains x.toLowerCase)
-  def setProp(name: String, value: String)      = System.setProperty(name, value)
-  def clearProp(name: String)                   = System.clearProperty(name)
+  def propIsSet(name: String): Boolean                  = System.getProperty(name) != null
+  def propIsSetTo(name: String, value: String): Boolean = propOrNull(name) == value
+  def propOrElse(name: String, alt: String): String     = System.getProperty(name, alt)
+  def propOrEmpty(name: String): String                 = propOrElse(name, "")
+  def propOrNull(name: String): String                  = propOrElse(name, null)
+  def propOrNone(name: String): Option[String]          = Option(propOrNull(name))
+  def propOrFalse(name: String): Boolean                = propOrNone(name) exists (x => List("yes", "on", "true") contains x.toLowerCase)
+  def setProp(name: String, value: String): String      = System.setProperty(name, value)
+  def clearProp(name: String): String                   = System.clearProperty(name)
 
-  def envOrElse(name: String, alt: String)      = Option(System getenv name) getOrElse alt
-  def envOrNone(name: String)                   = Option(System getenv name)
+  def envOrElse(name: String, alt: String): String      = Option(System getenv name) getOrElse alt
+  def envOrNone(name: String): Option[String]           = Option(System getenv name)
 
   // for values based on propFilename
   def scalaPropOrElse(name: String, alt: String): String = scalaProps.getProperty(name, alt)
@@ -62,12 +62,12 @@ trait PropertiesTrait {
   /** Either the development or release version if known, otherwise
    *  the empty string.
    */
-  def versionNumberString = scalaPropOrEmpty("version.number")
+  def versionNumberString: String = scalaPropOrEmpty("version.number")
 
   /** The version number of the jar this was loaded from plus "version " prefix,
    *  or "version (unknown)" if it cannot be determined.
    */
-  val versionString = {
+  val versionString: String = {
     val v = scalaPropOrElse("version.number", "(unknown)")
     "version " + scalaPropOrElse("version.number", "(unknown)") + {
       if (v.contains("SNAPSHOT") || v.contains("NIGHTLY")) {
@@ -82,53 +82,53 @@ trait PropertiesTrait {
    *  2. Features supported by experimental versions of the compiler:
    *     - research plugins
    */
-  val experimental = versionString.contains("SNAPSHOT") || versionString.contains("NIGHTLY")
+  val experimental: Boolean = versionString.contains("SNAPSHOT") || versionString.contains("NIGHTLY")
 
-  val copyrightString       = scalaPropOrElse("copyright.string", "(c) 2002-2017 LAMP/EPFL")
+  val copyrightString: String       = scalaPropOrElse("copyright.string", "(c) 2002-2017 LAMP/EPFL")
 
   /** This is the encoding to use reading in source files, overridden with -encoding
    *  Note that it uses "prop" i.e. looks in the scala jar, not the system properties.
    */
-  def sourceEncoding        = scalaPropOrElse("file.encoding", "UTF-8")
-  def sourceReader          = scalaPropOrElse("source.reader", "scala.tools.nsc.io.SourceReader")
+  def sourceEncoding: String        = scalaPropOrElse("file.encoding", "UTF-8")
+  def sourceReader: String          = scalaPropOrElse("source.reader", "scala.tools.nsc.io.SourceReader")
 
   /** This is the default text encoding, overridden (unreliably) with
    *  `JAVA_OPTS="-Dfile.encoding=Foo"`
    */
-  def encodingString        = propOrElse("file.encoding", "UTF-8")
+  def encodingString: String        = propOrElse("file.encoding", "UTF-8")
 
   /** The default end of line character.
    */
-  def lineSeparator         = propOrElse("line.separator", "\n")
+  def lineSeparator: String         = propOrElse("line.separator", "\n")
 
   /** Various well-known properties.
    */
-  def javaClassPath         = propOrEmpty("java.class.path")
-  def javaHome              = propOrEmpty("java.home")
-  def javaVendor            = propOrEmpty("java.vendor")
-  def javaVersion           = propOrEmpty("java.version")
-  def javaVmInfo            = propOrEmpty("java.vm.info")
-  def javaVmName            = propOrEmpty("java.vm.name")
-  def javaVmVendor          = propOrEmpty("java.vm.vendor")
-  def javaVmVersion         = propOrEmpty("java.vm.version")
-  def osName                = propOrEmpty("os.name")
-  def scalaHome             = propOrEmpty("scala.home")
-  def tmpDir                = propOrEmpty("java.io.tmpdir")
-  def userDir               = propOrEmpty("user.dir")
-  def userHome              = propOrEmpty("user.home")
-  def userName              = propOrEmpty("user.name")
+  def javaClassPath: String         = propOrEmpty("java.class.path")
+  def javaHome: String              = propOrEmpty("java.home")
+  def javaVendor: String            = propOrEmpty("java.vendor")
+  def javaVersion: String           = propOrEmpty("java.version")
+  def javaVmInfo: String            = propOrEmpty("java.vm.info")
+  def javaVmName: String            = propOrEmpty("java.vm.name")
+  def javaVmVendor: String          = propOrEmpty("java.vm.vendor")
+  def javaVmVersion: String         = propOrEmpty("java.vm.version")
+  def osName: String                = propOrEmpty("os.name")
+  def scalaHome: String             = propOrEmpty("scala.home")
+  def tmpDir: String                = propOrEmpty("java.io.tmpdir")
+  def userDir: String               = propOrEmpty("user.dir")
+  def userHome: String              = propOrEmpty("user.home")
+  def userName: String              = propOrEmpty("user.name")
 
   /** Some derived values.
    */
-  def isWin                 = osName startsWith "Windows"
-  def isMac                 = javaVendor startsWith "Apple"
+  def isWin: Boolean                = osName startsWith "Windows"
+  def isMac: Boolean                = javaVendor startsWith "Apple"
 
   // This is looking for javac, tools.jar, etc.
   // Tries JDK_HOME first, then the more common but likely jre JAVA_HOME,
   // and finally the system property based javaHome.
-  def jdkHome              = envOrElse("JDK_HOME", envOrElse("JAVA_HOME", javaHome))
+  def jdkHome: String               = envOrElse("JDK_HOME", envOrElse("JAVA_HOME", javaHome))
 
-  def versionMsg            = "Scala %s %s -- %s".format(propCategory, versionString, copyrightString)
-  def scalaCmd              = if (isWin) "dotr.bat" else "dotr"
-  def scalacCmd             = if (isWin) "dotc.bat" else "dotc"
+  def versionMsg: String            = "Scala %s %s -- %s".format(propCategory, versionString, copyrightString)
+  def scalaCmd: String              = if (isWin) "dotr.bat" else "dotr"
+  def scalacCmd: String             = if (isWin) "dotc.bat" else "dotc"
 }
diff --git a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
index 234553118300..07a52d32a778 100644
--- a/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
+++ b/compiler/src/dotty/tools/dotc/config/ScalaSettings.scala
@@ -1,153 +1,152 @@
 package dotty.tools.dotc
 package config
 
-import java.io.File
-import dotty.tools.io.{ Directory, PlainDirectory }
-
+import dotty.tools.io.{ Directory, PlainDirectory, AbstractFile }
 import PathResolver.Defaults
 import rewrites.Rewrites
+import Settings.Setting
 
 class ScalaSettings extends Settings.SettingGroup {
 
-  protected def defaultClasspath = sys.env.getOrElse("CLASSPATH", ".")
+  protected def defaultClasspath: String = sys.env.getOrElse("CLASSPATH", ".")
 
   /** Path related settings */
-  val bootclasspath = PathSetting("-bootclasspath", "Override location of bootstrap class files.", Defaults.scalaBootClassPath)
-  val extdirs = PathSetting("-extdirs", "Override location of installed extensions.", Defaults.scalaExtDirs)
-  val javabootclasspath = PathSetting("-javabootclasspath", "Override java boot classpath.", Defaults.javaBootClassPath)
-  val javaextdirs = PathSetting("-javaextdirs", "Override java extdirs classpath.", Defaults.javaExtDirs)
-  val sourcepath = PathSetting("-sourcepath", "Specify location(s) of source files.", Defaults.scalaSourcePath)
-  val scansource = BooleanSetting("-scansource", "Scan source files to locate classes for which class-name != file-name")
-
-  val classpath = PathSetting("-classpath", "Specify where to find user class files.", defaultClasspath) withAbbreviation "-cp"
-  val outputDir = OutputSetting("-d", "directory|jar", "destination for generated classfiles.",
+  val bootclasspath: Setting[String] = PathSetting("-bootclasspath", "Override location of bootstrap class files.", Defaults.scalaBootClassPath)
+  val extdirs: Setting[String] = PathSetting("-extdirs", "Override location of installed extensions.", Defaults.scalaExtDirs)
+  val javabootclasspath: Setting[String] = PathSetting("-javabootclasspath", "Override java boot classpath.", Defaults.javaBootClassPath)
+  val javaextdirs: Setting[String] = PathSetting("-javaextdirs", "Override java extdirs classpath.", Defaults.javaExtDirs)
+  val sourcepath: Setting[String] = PathSetting("-sourcepath", "Specify location(s) of source files.", Defaults.scalaSourcePath)
+  val scansource: Setting[Boolean] = BooleanSetting("-scansource", "Scan source files to locate classes for which class-name != file-name")
+
+  val classpath: Setting[String] = PathSetting("-classpath", "Specify where to find user class files.", defaultClasspath) withAbbreviation "-cp"
+  val outputDir: Setting[AbstractFile] = OutputSetting("-d", "directory|jar", "destination for generated classfiles.",
     new PlainDirectory(Directory(".")))
-  val priorityclasspath = PathSetting("-priorityclasspath", "class path that takes precedence over all other paths (or testing only)", "")
+  val priorityclasspath: Setting[String] = PathSetting("-priorityclasspath", "class path that takes precedence over all other paths (or testing only)", "")
 
   /** Other settings */
-  val deprecation = BooleanSetting("-deprecation", "Emit warning and location for usages of deprecated APIs.")
-  val migration = BooleanSetting("-migration", "Emit warning and location for migration issues from Scala 2.")
-  val encoding = StringSetting("-encoding", "encoding", "Specify character encoding used by source files.", Properties.sourceEncoding)
-  val explainTypes = BooleanSetting("-explain-types", "Explain type errors in more detail.")
-  val explain = BooleanSetting("-explain", "Explain errors in more detail.")
-  val feature = BooleanSetting("-feature", "Emit warning and location for usages of features that should be imported explicitly.")
-  val help = BooleanSetting("-help", "Print a synopsis of standard options")
-  val color = ChoiceSetting("-color", "mode", "Colored output", List("always", "never"/*, "auto"*/), "always"/* "auto"*/)
-  val target = ChoiceSetting("-target", "target", "Target platform for object files. All JVM 1.5 targets are deprecated.",
+  val deprecation: Setting[Boolean] = BooleanSetting("-deprecation", "Emit warning and location for usages of deprecated APIs.")
+  val migration: Setting[Boolean] = BooleanSetting("-migration", "Emit warning and location for migration issues from Scala 2.")
+  val encoding: Setting[String] = StringSetting("-encoding", "encoding", "Specify character encoding used by source files.", Properties.sourceEncoding)
+  val explainTypes: Setting[Boolean] = BooleanSetting("-explain-types", "Explain type errors in more detail.")
+  val explain: Setting[Boolean] = BooleanSetting("-explain", "Explain errors in more detail.")
+  val feature: Setting[Boolean] = BooleanSetting("-feature", "Emit warning and location for usages of features that should be imported explicitly.")
+  val help: Setting[Boolean] = BooleanSetting("-help", "Print a synopsis of standard options")
+  val color: Setting[String] = ChoiceSetting("-color", "mode", "Colored output", List("always", "never"/*, "auto"*/), "always"/* "auto"*/)
+  val target: Setting[String] = ChoiceSetting("-target", "target", "Target platform for object files. All JVM 1.5 targets are deprecated.",
     List("jvm-1.5", "jvm-1.5-fjbg", "jvm-1.5-asm", "jvm-1.6", "jvm-1.7", "jvm-1.8", "msil"), "jvm-1.8")
-  val unchecked = BooleanSetting("-unchecked", "Enable additional warnings where generated code depends on assumptions.")
-  val uniqid = BooleanSetting("-uniqid", "Uniquely tag all identifiers in debugging output.")
-  val usejavacp = BooleanSetting("-usejavacp", "Utilize the java.class.path in classpath resolution.")
-  val verbose = BooleanSetting("-verbose", "Output messages about what the compiler is doing.")
-  val version = BooleanSetting("-version", "Print product version and exit.")
-  val pageWidth = IntSetting("-pagewidth", "Set page width", 80)
-  val strict = BooleanSetting("-strict", "Use strict type rules, which means some formerly legal code does not typecheck anymore.")
-  val language = MultiStringSetting("-language", "feature", "Enable one or more language features.")
-  val rewrite = OptionSetting[Rewrites]("-rewrite", "When used in conjunction with -language:Scala2 rewrites sources to migrate to new syntax")
-  val silentWarnings = BooleanSetting("-nowarn", "Silence all warnings.")
-  val fromTasty = BooleanSetting("-from-tasty", "Compile classes from tasty in classpath. The arguments are used as class names.")
+  val unchecked: Setting[Boolean] = BooleanSetting("-unchecked", "Enable additional warnings where generated code depends on assumptions.")
+  val uniqid: Setting[Boolean] = BooleanSetting("-uniqid", "Uniquely tag all identifiers in debugging output.")
+  val usejavacp: Setting[Boolean] = BooleanSetting("-usejavacp", "Utilize the java.class.path in classpath resolution.")
+  val verbose: Setting[Boolean] = BooleanSetting("-verbose", "Output messages about what the compiler is doing.")
+  val version: Setting[Boolean] = BooleanSetting("-version", "Print product version and exit.")
+  val pageWidth: Setting[Int] = IntSetting("-pagewidth", "Set page width", 80)
+  val strict: Setting[Boolean] = BooleanSetting("-strict", "Use strict type rules, which means some formerly legal code does not typecheck anymore.")
+  val language: Setting[List[String]] = MultiStringSetting("-language", "feature", "Enable one or more language features.")
+  val rewrite: Setting[Option[Rewrites]] = OptionSetting[Rewrites]("-rewrite", "When used in conjunction with -language:Scala2 rewrites sources to migrate to new syntax")
+  val silentWarnings: Setting[Boolean] = BooleanSetting("-nowarn", "Silence all warnings.")
+  val fromTasty: Setting[Boolean] = BooleanSetting("-from-tasty", "Compile classes from tasty in classpath. The arguments are used as class names.")
 
   /** Decompiler settings */
-  val printTasty = BooleanSetting("-print-tasty", "Prints the raw tasty.")
-  val printLines = BooleanSetting("-print-lines", "Show source code line numbers.")
+  val printTasty: Setting[Boolean] = BooleanSetting("-print-tasty", "Prints the raw tasty.")
+  val printLines: Setting[Boolean] = BooleanSetting("-print-lines", "Show source code line numbers.")
 
   /** Plugin-related setting */
-  val plugin             = MultiStringSetting  ("-Xplugin", "paths", "Load a plugin from each classpath.")
-  val disable            = MultiStringSetting  ("-Xplugin-disable", "plugin", "Disable plugins by name.")
-  val require            = MultiStringSetting  ("-Xplugin-require", "plugin", "Abort if a named plugin is not loaded.")
-  val showPlugins        = BooleanSetting      ("-Xplugin-list", "Print a synopsis of loaded plugins.")
-  val pluginsDir         = StringSetting       ("-Xpluginsdir", "path", "Path to search for plugin archives.", Defaults.scalaPluginPath)
-  val pluginOptions      = MultiStringSetting  ("-P", "plugin:opt", "Pass an option to a plugin, e.g. -P:<plugin>:<opt>")
+  val plugin: Setting[List[String]]             = MultiStringSetting  ("-Xplugin", "paths", "Load a plugin from each classpath.")
+  val disable: Setting[List[String]]            = MultiStringSetting  ("-Xplugin-disable", "plugin", "Disable plugins by name.")
+  val require: Setting[List[String]]            = MultiStringSetting  ("-Xplugin-require", "plugin", "Abort if a named plugin is not loaded.")
+  val showPlugins: Setting[Boolean]        = BooleanSetting      ("-Xplugin-list", "Print a synopsis of loaded plugins.")
+  val pluginsDir: Setting[String]         = StringSetting       ("-Xpluginsdir", "path", "Path to search for plugin archives.", Defaults.scalaPluginPath)
+  val pluginOptions: Setting[List[String]]      = MultiStringSetting  ("-P", "plugin:opt", "Pass an option to a plugin, e.g. -P:<plugin>:<opt>")
 
   /** -X "Advanced" settings
    */
-  val Xhelp = BooleanSetting("-X", "Print a synopsis of advanced options.")
-  val XnoForwarders = BooleanSetting("-Xno-forwarders", "Do not generate static forwarders in mirror classes.")
-  val XminImplicitSearchDepth = IntSetting("-Xmin-implicit-search-depth", "Set number of levels of implicit searches undertaken before checking for divergence.", 5)
-  val XmaxInlines = IntSetting("-Xmax-inlines", "Maximal number of successive inlines", 32)
-  val XmaxClassfileName = IntSetting("-Xmax-classfile-name", "Maximum filename length for generated classes", 255, 72 to 255)
-  val Xmigration = VersionSetting("-Xmigration", "Warn about constructs whose behavior may have changed since version.")
-  val Xprint = PhasesSetting("-Xprint", "Print out program after")
-  val XprintTypes = BooleanSetting("-Xprint-types", "Print tree types (debugging option).")
-  val XprintDiff = BooleanSetting("-Xprint-diff", "Print changed parts of the tree since last print.")
-  val XprintDiffDel = BooleanSetting("-Xprint-diff-del", "Print changed parts of the tree since last print including deleted parts.")
-  val Xprompt = BooleanSetting("-Xprompt", "Display a prompt after each error (debugging option).")
-  val XmainClass = StringSetting("-Xmain-class", "path", "Class for manifest's Main-Class entry (only useful with -d <jar>)", "")
-  val XnoValueClasses = BooleanSetting("-Xno-value-classes", "Do not use value classes. Helps debugging.")
-  val XreplLineWidth = IntSetting("-Xrepl-line-width", "Maximal number of columns per line for REPL output", 390)
-  val XfatalWarnings = BooleanSetting("-Xfatal-warnings", "Fail the compilation if there are any warnings.")
-  val XverifySignatures = BooleanSetting("-Xverify-signatures", "Verify generic signatures in generated bytecode.")
+  val Xhelp: Setting[Boolean] = BooleanSetting("-X", "Print a synopsis of advanced options.")
+  val XnoForwarders: Setting[Boolean] = BooleanSetting("-Xno-forwarders", "Do not generate static forwarders in mirror classes.")
+  val XminImplicitSearchDepth: Setting[Int] = IntSetting("-Xmin-implicit-search-depth", "Set number of levels of implicit searches undertaken before checking for divergence.", 5)
+  val XmaxInlines: Setting[Int] = IntSetting("-Xmax-inlines", "Maximal number of successive inlines", 32)
+  val XmaxClassfileName: Setting[Int] = IntSetting("-Xmax-classfile-name", "Maximum filename length for generated classes", 255, 72 to 255)
+  val Xmigration: Setting[ScalaVersion] = VersionSetting("-Xmigration", "Warn about constructs whose behavior may have changed since version.")
+  val Xprint: Setting[List[String]] = PhasesSetting("-Xprint", "Print out program after")
+  val XprintTypes: Setting[Boolean] = BooleanSetting("-Xprint-types", "Print tree types (debugging option).")
+  val XprintDiff: Setting[Boolean] = BooleanSetting("-Xprint-diff", "Print changed parts of the tree since last print.")
+  val XprintDiffDel: Setting[Boolean] = BooleanSetting("-Xprint-diff-del", "Print changed parts of the tree since last print including deleted parts.")
+  val Xprompt: Setting[Boolean] = BooleanSetting("-Xprompt", "Display a prompt after each error (debugging option).")
+  val XmainClass: Setting[String] = StringSetting("-Xmain-class", "path", "Class for manifest's Main-Class entry (only useful with -d <jar>)", "")
+  val XnoValueClasses: Setting[Boolean] = BooleanSetting("-Xno-value-classes", "Do not use value classes. Helps debugging.")
+  val XreplLineWidth: Setting[Int] = IntSetting("-Xrepl-line-width", "Maximal number of columns per line for REPL output", 390)
+  val XfatalWarnings: Setting[Boolean] = BooleanSetting("-Xfatal-warnings", "Fail the compilation if there are any warnings.")
+  val XverifySignatures: Setting[Boolean] = BooleanSetting("-Xverify-signatures", "Verify generic signatures in generated bytecode.")
 
   /** -Y "Private" settings */
-  val YoverrideVars = BooleanSetting("-Yoverride-vars", "Allow vars to be overridden.")
-  val Yhelp = BooleanSetting("-Y", "Print a synopsis of private options.")
-  val Ycheck = PhasesSetting("-Ycheck", "Check the tree at the end of")
-  val YcheckMods = BooleanSetting("-Ycheck-mods", "Check that symbols and their defining trees have modifiers in sync")
-  val Ydebug = BooleanSetting("-Ydebug", "Increase the quantity of debugging output.")
-  val YdebugTrace = BooleanSetting("-Ydebug-trace", "Trace core operations")
-  val YdebugFlags = BooleanSetting("-Ydebug-flags", "Print all flags of definitions")
-  val YdebugMissingRefs = BooleanSetting("-Ydebug-missing-refs", "Print a stacktrace when a required symbol is missing")
-  val YdebugNames = BooleanSetting("-Ydebug-names", "Show internal representation of names")
-  val YtermConflict = ChoiceSetting("-Yresolve-term-conflict", "strategy", "Resolve term conflicts", List("package", "object", "error"), "error")
-  val Ylog = PhasesSetting("-Ylog", "Log operations during")
-  val YemitTastyInClass = BooleanSetting("-Yemit-tasty-in-class", "Generate tasty in the .class file and add an empty *.hasTasty file.")
-  val YlogClasspath = BooleanSetting("-Ylog-classpath", "Output information about what classpath is being applied.")
-  val YdisableFlatCpCaching  = BooleanSetting("-YdisableFlatCpCaching", "Do not cache flat classpath representation of classpath elements from jars across compiler instances.")
-
-  val Yscala2Unpickler = StringSetting("-Yscala2-unpickler", "", "Control where we may get Scala 2 symbols from. This is either \"always\", \"never\", or a classpath.", "always")
-
-  val YnoImports = BooleanSetting("-Yno-imports", "Compile without importing scala.*, java.lang.*, or Predef.")
-  val YnoInline = BooleanSetting("-Yno-inline", "Suppress inlining.")
-  val YnoGenericSig = BooleanSetting("-Yno-generic-signatures", "Suppress generation of generic signatures for Java.")
-  val YnoPredef = BooleanSetting("-Yno-predef", "Compile without importing Predef.")
-  val Yskip = PhasesSetting("-Yskip", "Skip")
-  val Ydumpclasses = StringSetting("-Ydump-classes", "dir", "Dump the generated bytecode to .class files (useful for reflective compilation that utilizes in-memory classloaders).", "")
-  val YstopAfter = PhasesSetting("-Ystop-after", "Stop after") withAbbreviation ("-stop") // backward compat
-  val YstopBefore = PhasesSetting("-Ystop-before", "Stop before") // stop before erasure as long as we have not debugged it fully
-  val YtraceContextCreation = BooleanSetting("-Ytrace-context-creation", "Store stack trace of context creations.")
-  val YshowSuppressedErrors = BooleanSetting("-Yshow-suppressed-errors", "Also show follow-on errors and warnings that are normally suppressed.")
-  val YdetailedStats = BooleanSetting("-Ydetailed-stats", "show detailed internal compiler stats (needs Stats.enabled to be set to true).")
-  val Yheartbeat = BooleanSetting("-Ydetailed-stats", "show heartbeat stack trace of compiler operations (needs Stats.enabled to be set to true).")
-  val YprintPos = BooleanSetting("-Yprint-pos", "show tree positions.")
-  val YprintPosSyms = BooleanSetting("-Yprint-pos-syms", "show symbol definitions positions.")
-  val YnoDeepSubtypes = BooleanSetting("-Yno-deep-subtypes", "throw an exception on deep subtyping call stacks.")
-  val YnoPatmatOpt = BooleanSetting("-Yno-patmat-opt", "disable all pattern matching optimizations.")
-  val YplainPrinter = BooleanSetting("-Yplain-printer", "Pretty-print using a plain printer.")
-  val YprintSyms = BooleanSetting("-Yprint-syms", "when printing trees print info in symbols instead of corresponding info in trees.")
-  val YprintDebug = BooleanSetting("-Yprint-debug", "when printing trees, print some extra information useful for debugging.")
-  val YprintDebugOwners = BooleanSetting("-Yprint-debug-owners", "when printing trees, print owners of definitions.")
-  val YshowPrintErrors = BooleanSetting("-Yshow-print-errors", "don't suppress exceptions thrown during tree printing.")
-  val YtestPickler = BooleanSetting("-Ytest-pickler", "self-test for pickling functionality; should be used with -Ystop-after:pickler")
-  val YcheckReentrant = BooleanSetting("-Ycheck-reentrant", "check that compiled program does not contain vars that can be accessed from a global root.")
-  val YdropComments = BooleanSetting("-Ydrop-comments", "Drop comments when scanning source files.")
-  val YcookComments = BooleanSetting("-Ycook-comments", "Cook the comments (type check `@usecase`, etc.)")
-  val YforceSbtPhases = BooleanSetting("-Yforce-sbt-phases", "Run the phases used by sbt for incremental compilation (ExtractDependencies and ExtractAPI) even if the compiler is ran outside of sbt, for debugging.")
-  val YdumpSbtInc = BooleanSetting("-Ydump-sbt-inc", "For every compiled foo.scala, output the API representation and dependencies used for sbt incremental compilation in foo.inc, implies -Yforce-sbt-phases.")
-  val YcheckAllPatmat = BooleanSetting("-Ycheck-all-patmat", "Check exhaustivity and redundancy of all pattern matching (used for testing the algorithm)")
-  val YretainTrees = BooleanSetting("-Yretain-trees", "Retain trees for top-level classes, accessible from ClassSymbol#tree")
-  val YshowTreeIds = BooleanSetting("-Yshow-tree-ids", "Uniquely tag all tree nodes in debugging output.")
-
-  val YprofileEnabled = BooleanSetting("-Yprofile-enabled", "Enable profiling.")
-  val YprofileDestination = StringSetting("-Yprofile-destination", "file", "where to send profiling output - specify a file, default is to the console.", "")
+  val YoverrideVars: Setting[Boolean] = BooleanSetting("-Yoverride-vars", "Allow vars to be overridden.")
+  val Yhelp: Setting[Boolean] = BooleanSetting("-Y", "Print a synopsis of private options.")
+  val Ycheck: Setting[List[String]] = PhasesSetting("-Ycheck", "Check the tree at the end of")
+  val YcheckMods: Setting[Boolean] = BooleanSetting("-Ycheck-mods", "Check that symbols and their defining trees have modifiers in sync")
+  val Ydebug: Setting[Boolean] = BooleanSetting("-Ydebug", "Increase the quantity of debugging output.")
+  val YdebugTrace: Setting[Boolean] = BooleanSetting("-Ydebug-trace", "Trace core operations")
+  val YdebugFlags: Setting[Boolean] = BooleanSetting("-Ydebug-flags", "Print all flags of definitions")
+  val YdebugMissingRefs: Setting[Boolean] = BooleanSetting("-Ydebug-missing-refs", "Print a stacktrace when a required symbol is missing")
+  val YdebugNames: Setting[Boolean] = BooleanSetting("-Ydebug-names", "Show internal representation of names")
+  val YtermConflict: Setting[String] = ChoiceSetting("-Yresolve-term-conflict", "strategy", "Resolve term conflicts", List("package", "object", "error"), "error")
+  val Ylog: Setting[List[String]] = PhasesSetting("-Ylog", "Log operations during")
+  val YemitTastyInClass: Setting[Boolean] = BooleanSetting("-Yemit-tasty-in-class", "Generate tasty in the .class file and add an empty *.hasTasty file.")
+  val YlogClasspath: Setting[Boolean] = BooleanSetting("-Ylog-classpath", "Output information about what classpath is being applied.")
+  val YdisableFlatCpCaching: Setting[Boolean]  = BooleanSetting("-YdisableFlatCpCaching", "Do not cache flat classpath representation of classpath elements from jars across compiler instances.")
+
+  val Yscala2Unpickler: Setting[String] = StringSetting("-Yscala2-unpickler", "", "Control where we may get Scala 2 symbols from. This is either \"always\", \"never\", or a classpath.", "always")
+
+  val YnoImports: Setting[Boolean] = BooleanSetting("-Yno-imports", "Compile without importing scala.*, java.lang.*, or Predef.")
+  val YnoInline: Setting[Boolean] = BooleanSetting("-Yno-inline", "Suppress inlining.")
+  val YnoGenericSig: Setting[Boolean] = BooleanSetting("-Yno-generic-signatures", "Suppress generation of generic signatures for Java.")
+  val YnoPredef: Setting[Boolean] = BooleanSetting("-Yno-predef", "Compile without importing Predef.")
+  val Yskip: Setting[List[String]] = PhasesSetting("-Yskip", "Skip")
+  val Ydumpclasses: Setting[String] = StringSetting("-Ydump-classes", "dir", "Dump the generated bytecode to .class files (useful for reflective compilation that utilizes in-memory classloaders).", "")
+  val YstopAfter: Setting[List[String]] = PhasesSetting("-Ystop-after", "Stop after") withAbbreviation ("-stop") // backward compat
+  val YstopBefore: Setting[List[String]] = PhasesSetting("-Ystop-before", "Stop before") // stop before erasure as long as we have not debugged it fully
+  val YtraceContextCreation: Setting[Boolean] = BooleanSetting("-Ytrace-context-creation", "Store stack trace of context creations.")
+  val YshowSuppressedErrors: Setting[Boolean] = BooleanSetting("-Yshow-suppressed-errors", "Also show follow-on errors and warnings that are normally suppressed.")
+  val YdetailedStats: Setting[Boolean] = BooleanSetting("-Ydetailed-stats", "show detailed internal compiler stats (needs Stats.enabled to be set to true).")
+  val Yheartbeat: Setting[Boolean] = BooleanSetting("-Ydetailed-stats", "show heartbeat stack trace of compiler operations (needs Stats.enabled to be set to true).")
+  val YprintPos: Setting[Boolean] = BooleanSetting("-Yprint-pos", "show tree positions.")
+  val YprintPosSyms: Setting[Boolean] = BooleanSetting("-Yprint-pos-syms", "show symbol definitions positions.")
+  val YnoDeepSubtypes: Setting[Boolean] = BooleanSetting("-Yno-deep-subtypes", "throw an exception on deep subtyping call stacks.")
+  val YnoPatmatOpt: Setting[Boolean] = BooleanSetting("-Yno-patmat-opt", "disable all pattern matching optimizations.")
+  val YplainPrinter: Setting[Boolean] = BooleanSetting("-Yplain-printer", "Pretty-print using a plain printer.")
+  val YprintSyms: Setting[Boolean] = BooleanSetting("-Yprint-syms", "when printing trees print info in symbols instead of corresponding info in trees.")
+  val YprintDebug: Setting[Boolean] = BooleanSetting("-Yprint-debug", "when printing trees, print some extra information useful for debugging.")
+  val YprintDebugOwners: Setting[Boolean] = BooleanSetting("-Yprint-debug-owners", "when printing trees, print owners of definitions.")
+  val YshowPrintErrors: Setting[Boolean] = BooleanSetting("-Yshow-print-errors", "don't suppress exceptions thrown during tree printing.")
+  val YtestPickler: Setting[Boolean] = BooleanSetting("-Ytest-pickler", "self-test for pickling functionality; should be used with -Ystop-after:pickler")
+  val YcheckReentrant: Setting[Boolean] = BooleanSetting("-Ycheck-reentrant", "check that compiled program does not contain vars that can be accessed from a global root.")
+  val YdropComments: Setting[Boolean] = BooleanSetting("-Ydrop-comments", "Drop comments when scanning source files.")
+  val YcookComments: Setting[Boolean] = BooleanSetting("-Ycook-comments", "Cook the comments (type check `@usecase`, etc.)")
+  val YforceSbtPhases: Setting[Boolean] = BooleanSetting("-Yforce-sbt-phases", "Run the phases used by sbt for incremental compilation (ExtractDependencies and ExtractAPI) even if the compiler is ran outside of sbt, for debugging.")
+  val YdumpSbtInc: Setting[Boolean] = BooleanSetting("-Ydump-sbt-inc", "For every compiled foo.scala, output the API representation and dependencies used for sbt incremental compilation in foo.inc, implies -Yforce-sbt-phases.")
+  val YcheckAllPatmat: Setting[Boolean] = BooleanSetting("-Ycheck-all-patmat", "Check exhaustivity and redundancy of all pattern matching (used for testing the algorithm)")
+  val YretainTrees: Setting[Boolean] = BooleanSetting("-Yretain-trees", "Retain trees for top-level classes, accessible from ClassSymbol#tree")
+  val YshowTreeIds: Setting[Boolean] = BooleanSetting("-Yshow-tree-ids", "Uniquely tag all tree nodes in debugging output.")
+
+  val YprofileEnabled: Setting[Boolean] = BooleanSetting("-Yprofile-enabled", "Enable profiling.")
+  val YprofileDestination: Setting[String] = StringSetting("-Yprofile-destination", "file", "where to send profiling output - specify a file, default is to the console.", "")
       //.withPostSetHook( _ => YprofileEnabled.value = true )
-  val YprofileExternalTool = PhasesSetting("-Yprofile-external-tool", "Enable profiling for a phase using an external tool hook. Generally only useful for a single phase", "typer")
+  val YprofileExternalTool: Setting[List[String]] = PhasesSetting("-Yprofile-external-tool", "Enable profiling for a phase using an external tool hook. Generally only useful for a single phase", "typer")
       //.withPostSetHook( _ => YprofileEnabled.value = true )
-  val YprofileRunGcBetweenPhases = PhasesSetting("-Yprofile-run-gc", "Run a GC between phases - this allows heap size to be accurate at the expense of more time. Specify a list of phases, or *", "_")
+  val YprofileRunGcBetweenPhases: Setting[List[String]] = PhasesSetting("-Yprofile-run-gc", "Run a GC between phases - this allows heap size to be accurate at the expense of more time. Specify a list of phases, or *", "_")
       //.withPostSetHook( _ => YprofileEnabled.value = true )
 
   // Extremely experimental language features
-  val YkindPolymorphism = BooleanSetting("-Ykind-polymorphism", "Enable kind polymorphism (see http://dotty.epfl.ch/docs/reference/kind-polymorphism.html). Potentially unsound.")
+  val YkindPolymorphism: Setting[Boolean] = BooleanSetting("-Ykind-polymorphism", "Enable kind polymorphism (see http://dotty.epfl.ch/docs/reference/kind-polymorphism.html). Potentially unsound.")
 
   /** Area-specific debug output */
-  val YexplainLowlevel = BooleanSetting("-Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")
-  val YnoDoubleBindings = BooleanSetting("-Yno-double-bindings", "Assert no namedtype is bound twice (should be enabled only if program is error-free).")
-  val YshowVarBounds = BooleanSetting("-Yshow-var-bounds", "Print type variables with their bounds")
-  val YshowNoInline = BooleanSetting("-Yshow-no-inline", "Show inlined code without the 'inlined from' info")
+  val YexplainLowlevel: Setting[Boolean] = BooleanSetting("-Yexplain-lowlevel", "When explaining type errors, show types at a lower level.")
+  val YnoDoubleBindings: Setting[Boolean] = BooleanSetting("-Yno-double-bindings", "Assert no namedtype is bound twice (should be enabled only if program is error-free).")
+  val YshowVarBounds: Setting[Boolean] = BooleanSetting("-Yshow-var-bounds", "Print type variables with their bounds")
+  val YshowNoInline: Setting[Boolean] = BooleanSetting("-Yshow-no-inline", "Show inlined code without the 'inlined from' info")
 
-  val YnoDecodeStacktraces = BooleanSetting("-Yno-decode-stacktraces", "Show raw StackOverflow stacktraces, instead of decoding them into triggering operations.")
+  val YnoDecodeStacktraces: Setting[Boolean] = BooleanSetting("-Yno-decode-stacktraces", "Show raw StackOverflow stacktraces, instead of decoding them into triggering operations.")
 
   /** Dottydoc specific settings */
-  val siteRoot = StringSetting(
+  val siteRoot: Setting[String] = StringSetting(
     "-siteroot",
     "site root",
     "A directory containing static files from which to generate documentation",
@@ -155,26 +154,26 @@ class ScalaSettings extends Settings.SettingGroup {
   )
 
 
-  val projectName = StringSetting (
+  val projectName: Setting[String] = StringSetting (
     "-project",
     "project title",
     "The name of the project",
     ""
   )
 
-  val projectVersion = StringSetting (
+  val projectVersion: Setting[String] = StringSetting (
     "-project-version",
     "project version",
     "The current version of your project",
     ""
   )
 
-  val projectUrl = StringSetting (
+  val projectUrl: Setting[String] = StringSetting (
     "-project-url",
     "project repository homepage",
     "The source repository of your project",
     ""
   )
 
-  val wikiSyntax = BooleanSetting("-Xwiki-syntax", "Retains the Scala2 behavior of using Wiki Syntax in Scaladoc")
+  val wikiSyntax: Setting[Boolean] = BooleanSetting("-Xwiki-syntax", "Retains the Scala2 behavior of using Wiki Syntax in Scaladoc")
 }
diff --git a/compiler/src/dotty/tools/dotc/config/ScalaVersion.scala b/compiler/src/dotty/tools/dotc/config/ScalaVersion.scala
index 9bb7431d5384..8ba3dce8306a 100644
--- a/compiler/src/dotty/tools/dotc/config/ScalaVersion.scala
+++ b/compiler/src/dotty/tools/dotc/config/ScalaVersion.scala
@@ -18,7 +18,7 @@ sealed abstract class ScalaVersion extends Ordered[ScalaVersion] {
  * A scala version that sorts higher than all actual versions
  */
 @sharable case object NoScalaVersion extends ScalaVersion {
-  def unparse = "none"
+  def unparse: String = "none"
 
   def compare(that: ScalaVersion): Int = that match {
     case NoScalaVersion => 0
@@ -33,7 +33,7 @@ sealed abstract class ScalaVersion extends Ordered[ScalaVersion] {
  * to segregate builds
  */
 case class SpecificScalaVersion(major: Int, minor: Int, rev: Int, build: ScalaBuild) extends ScalaVersion {
-  def unparse = s"${major}.${minor}.${rev}.${build.unparse}"
+  def unparse: String = s"${major}.${minor}.${rev}.${build.unparse}"
 
   def compare(that: ScalaVersion): Int =  that match {
     case SpecificScalaVersion(thatMajor, thatMinor, thatRev, thatBuild) =>
@@ -55,7 +55,7 @@ case class SpecificScalaVersion(major: Int, minor: Int, rev: Int, build: ScalaBu
  * A Scala version that sorts lower than all actual versions
  */
 @sharable case object AnyScalaVersion extends ScalaVersion {
-  def unparse = "any"
+  def unparse: String = "any"
 
   def compare(that: ScalaVersion): Int = that match {
     case AnyScalaVersion => 0
@@ -110,7 +110,7 @@ case class SpecificScalaVersion(major: Int, minor: Int, rev: Int, build: ScalaBu
   /**
    * The version of the compiler running now
    */
-  val current = parse(util.Properties.versionNumberString).get
+  val current: ScalaVersion = parse(util.Properties.versionNumberString).get
 }
 
 /**
@@ -129,9 +129,9 @@ object ScalaBuild {
   /** A development, test, nightly, snapshot or other "unofficial" build
    */
   case class Development(id: String) extends ScalaBuild {
-    def unparse = s"-${id}"
+    def unparse: String = s"-${id}"
 
-    def compare(that: ScalaBuild) = that match {
+    def compare(that: ScalaBuild): Int = that match {
       // sorting two development builds based on id is reasonably valid for two versions created with the same schema
       // otherwise it's not correct, but since it's impossible to put a total ordering on development build versions
       // this is a pragmatic compromise
@@ -145,9 +145,9 @@ object ScalaBuild {
   /** A final build
    */
   case object Final extends ScalaBuild {
-    def unparse = ""
+    def unparse: String = ""
 
-    def compare(that: ScalaBuild) = that match {
+    def compare(that: ScalaBuild): Int = that match {
       case Final => 0
       // a final is newer than anything other than a development build or another final
       case Development(_) => -1
@@ -158,9 +158,9 @@ object ScalaBuild {
   /** A candidate for final release
    */
   case class RC(n: Int) extends ScalaBuild {
-    def unparse = s"-RC${n}"
+    def unparse: String = s"-RC${n}"
 
-    def compare(that: ScalaBuild) = that match {
+    def compare(that: ScalaBuild): Int = that match {
       // compare two rcs based on their RC numbers
       case RC(thatN) => n - thatN
       // an rc is older than anything other than a milestone or another rc
@@ -172,9 +172,9 @@ object ScalaBuild {
   /** An intermediate release
    */
   case class Milestone(n: Int) extends ScalaBuild {
-    def unparse = s"-M${n}"
+    def unparse: String = s"-M${n}"
 
-    def compare(that: ScalaBuild) = that match {
+    def compare(that: ScalaBuild): Int = that match {
       // compare two milestones based on their milestone numbers
       case Milestone(thatN) => n - thatN
       // a milestone is older than anything other than another milestone
diff --git a/compiler/src/dotty/tools/dotc/config/Settings.scala b/compiler/src/dotty/tools/dotc/config/Settings.scala
index 35ed62aa6366..910cbe5da569 100644
--- a/compiler/src/dotty/tools/dotc/config/Settings.scala
+++ b/compiler/src/dotty/tools/dotc/config/Settings.scala
@@ -1,12 +1,12 @@
 package dotty.tools.dotc
 package config
 
-import collection.mutable.{ ArrayBuffer }
-import scala.util.{ Try, Success, Failure }
+import collection.mutable.ArrayBuffer
+import scala.util.{ Success, Failure }
 import reflect.ClassTag
 import core.Contexts._
 import scala.annotation.tailrec
-import dotty.tools.io.{ AbstractFile, Directory, JarArchive, PlainDirectory, File, Path }
+import dotty.tools.io.{ AbstractFile, Directory, JarArchive, PlainDirectory }
 
 // import annotation.unchecked
   // Dotty deviation: Imports take precedence over definitions in enclosing package
@@ -16,19 +16,19 @@ import language.existentials
 
 object Settings {
 
-  val BooleanTag = ClassTag.Boolean
-  val IntTag = ClassTag.Int
-  val StringTag = ClassTag(classOf[String])
-  val ListTag = ClassTag(classOf[List[_]])
-  val VersionTag = ClassTag(classOf[ScalaVersion])
-  val OptionTag = ClassTag(classOf[Option[_]])
-  val OutputTag = ClassTag(classOf[AbstractFile])
+  val BooleanTag: ClassTag[Boolean]      = ClassTag.Boolean
+  val IntTag: ClassTag[Int]              = ClassTag.Int
+  val StringTag: ClassTag[String]        = ClassTag(classOf[String])
+  val ListTag: ClassTag[List[_]]         = ClassTag(classOf[List[_]])
+  val VersionTag: ClassTag[ScalaVersion] = ClassTag(classOf[ScalaVersion])
+  val OptionTag: ClassTag[Option[_]]     = ClassTag(classOf[Option[_]])
+  val OutputTag: ClassTag[AbstractFile]  = ClassTag(classOf[AbstractFile])
 
   class SettingsState(initialValues: Seq[Any]) {
     private[this] var values = ArrayBuffer(initialValues: _*)
     private[this] var _wasRead: Boolean = false
 
-    override def toString = s"SettingsState(values: ${values.toList})"
+    override def toString: String = s"SettingsState(values: ${values.toList})"
 
     def value(idx: Int): Any = {
       _wasRead = true
@@ -50,10 +50,10 @@ object Settings {
     errors: List[String],
     warnings: List[String]) {
 
-    def fail(msg: String) =
+    def fail(msg: String): Settings.ArgsSummary =
       ArgsSummary(sstate, arguments.tail, errors :+ msg, warnings)
 
-    def warn(msg: String) =
+    def warn(msg: String): Settings.ArgsSummary =
       ArgsSummary(sstate, arguments.tail, errors, warnings :+ msg)
   }
 
@@ -193,15 +193,15 @@ object Settings {
 
   class SettingGroup {
 
-    val _allSettings = new ArrayBuffer[Setting[_]]
+    private[this] val _allSettings: ArrayBuffer[Setting[_]] = new ArrayBuffer[Setting[_]]
     def allSettings: Seq[Setting[_]] = _allSettings
 
-    def defaultState = new SettingsState(allSettings map (_.default))
+    def defaultState: SettingsState = new SettingsState(allSettings map (_.default))
 
-    def userSetSettings(state: SettingsState) =
+    def userSetSettings(state: SettingsState): Seq[Setting[_]] =
       allSettings filterNot (_.isDefaultIn(state))
 
-    def toConciseString(state: SettingsState) =
+    def toConciseString(state: SettingsState): String =
       userSetSettings(state).mkString("(", " ", ")")
 
     private def checkDependencies(state: ArgsSummary): ArgsSummary =
diff --git a/compiler/src/dotty/tools/dotc/config/WrappedProperties.scala b/compiler/src/dotty/tools/dotc/config/WrappedProperties.scala
index 07972b99b937..e80052872e7c 100644
--- a/compiler/src/dotty/tools/dotc/config/WrappedProperties.scala
+++ b/compiler/src/dotty/tools/dotc/config/WrappedProperties.scala
@@ -11,15 +11,15 @@ import java.security.AccessControlException
 trait WrappedProperties extends PropertiesTrait {
   def wrap[T](body: => T): Option[T]
 
-  protected def propCategory   = "wrapped"
-  protected def pickJarBasedOn = this.getClass
+  protected def propCategory: String     = "wrapped"
+  protected def pickJarBasedOn: Class[_] = this.getClass
 
-  override def propIsSet(name: String)               = wrap(super.propIsSet(name)) exists (x => x)
-  override def propOrElse(name: String, alt: String) = wrap(super.propOrElse(name, alt)) getOrElse alt
-  override def setProp(name: String, value: String)  = wrap(super.setProp(name, value)).orNull
-  override def clearProp(name: String)               = wrap(super.clearProp(name)).orNull
-  override def envOrElse(name: String, alt: String)  = wrap(super.envOrElse(name, alt)) getOrElse alt
-  override def envOrNone(name: String)               = wrap(super.envOrNone(name)).flatten
+  override def propIsSet(name: String): Boolean              = wrap(super.propIsSet(name)) exists (x => x)
+  override def propOrElse(name: String, alt: String): String = wrap(super.propOrElse(name, alt)) getOrElse alt
+  override def setProp(name: String, value: String): String  = wrap(super.setProp(name, value)).orNull
+  override def clearProp(name: String): String               = wrap(super.clearProp(name)).orNull
+  override def envOrElse(name: String, alt: String): String  = wrap(super.envOrElse(name, alt)) getOrElse alt
+  override def envOrNone(name: String): Option[String]       = wrap(super.envOrNone(name)).flatten
 
   def systemProperties: Iterator[(String, String)] = {
     import scala.collection.JavaConverters._
@@ -29,6 +29,6 @@ trait WrappedProperties extends PropertiesTrait {
 
 object WrappedProperties {
   object AccessControl extends WrappedProperties {
-    def wrap[T](body: => T) = try Some(body) catch { case _: AccessControlException => None }
+    def wrap[T](body: => T): Option[T] = try Some(body) catch { case _: AccessControlException => None }
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/Annotations.scala b/compiler/src/dotty/tools/dotc/core/Annotations.scala
index d99db77c36ae..6a081898ed03 100644
--- a/compiler/src/dotty/tools/dotc/core/Annotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Annotations.scala
@@ -1,10 +1,11 @@
 package dotty.tools.dotc
 package core
 
-import Symbols._, Types._, util.Positions._, Contexts._, Constants._, ast.tpd._
+import Symbols._, Types._, Contexts._, Constants._, ast.tpd._
 import config.ScalaVersion
 import StdNames._
-import dotty.tools.dotc.ast.{tpd, untpd}
+import dotty.tools.dotc.ast.tpd
+import scala.util.Try
 
 object Annotations {
 
@@ -19,10 +20,10 @@ object Annotations {
 
     def appliesToModule: Boolean = true // for now; see remark in SymDenotations
 
-    def derivedAnnotation(tree: Tree)(implicit ctx: Context) =
+    def derivedAnnotation(tree: Tree)(implicit ctx: Context): Annotation =
       if (tree eq this.tree) this else Annotation(tree)
 
-    def arguments(implicit ctx: Context) = ast.tpd.arguments(tree)
+    def arguments(implicit ctx: Context): List[Tree] = ast.tpd.arguments(tree)
 
     def argument(i: Int)(implicit ctx: Context): Option[Tree] = {
       val args = arguments
@@ -35,7 +36,7 @@ object Annotations {
 
     def ensureCompleted(implicit ctx: Context): Unit = tree
 
-    def sameAnnotation(that: Annotation)(implicit ctx: Context) =
+    def sameAnnotation(that: Annotation)(implicit ctx: Context): Boolean =
       symbol == that.symbol && tree.sameTree(that.tree)
   }
 
@@ -48,12 +49,12 @@ object Annotations {
     def complete(implicit ctx: Context): Tree
 
     private[this] var myTree: Tree = null
-    def tree(implicit ctx: Context) = {
+    def tree(implicit ctx: Context): Tree = {
       if (myTree == null) myTree = complete(ctx)
       myTree
     }
 
-    override def isEvaluated = myTree != null
+    override def isEvaluated: Boolean = myTree != null
   }
 
   /** An annotation indicating the body of a right-hand side,
@@ -61,21 +62,21 @@ object Annotations {
    *  pickling/unpickling and TypeTreeMaps
    */
   abstract class BodyAnnotation extends Annotation {
-    override def symbol(implicit ctx: Context) = defn.BodyAnnot
-    override def derivedAnnotation(tree: Tree)(implicit ctx: Context) =
+    override def symbol(implicit ctx: Context): ClassSymbol = defn.BodyAnnot
+    override def derivedAnnotation(tree: Tree)(implicit ctx: Context): Annotation =
       if (tree eq this.tree) this else ConcreteBodyAnnotation(tree)
-    override def arguments(implicit ctx: Context) = Nil
-    override def ensureCompleted(implicit ctx: Context) = ()
+    override def arguments(implicit ctx: Context): List[Tree] = Nil
+    override def ensureCompleted(implicit ctx: Context): Unit = ()
   }
 
   case class ConcreteBodyAnnotation(body: Tree) extends BodyAnnotation {
-    def tree(implicit ctx: Context) = body
+    def tree(implicit ctx: Context): Tree = body
   }
 
   case class LazyBodyAnnotation(private var bodyExpr: Context => Tree) extends BodyAnnotation {
     private[this] var evaluated = false
     private[this] var myBody: Tree = _
-    def tree(implicit ctx: Context) = {
+    def tree(implicit ctx: Context): Tree = {
       if (evaluated) assert(myBody != null)
       else {
         evaluated = true
@@ -84,12 +85,12 @@ object Annotations {
       }
       myBody
     }
-    override def isEvaluated = evaluated
+    override def isEvaluated: Boolean = evaluated
   }
 
   object Annotation {
 
-    def apply(tree: Tree) = ConcreteAnnotation(tree)
+    def apply(tree: Tree): ConcreteAnnotation = ConcreteAnnotation(tree)
 
     def apply(cls: ClassSymbol)(implicit ctx: Context): Annotation =
       apply(cls, Nil)
@@ -149,7 +150,7 @@ object Annotations {
     def deferredResolve(atp: Type, args: List[Tree])(implicit ctx: Context): Annotation =
       deferred(atp.classSymbol, implicit ctx => resolveConstructor(atp, args))
 
-    def makeAlias(sym: TermSymbol)(implicit ctx: Context) =
+    def makeAlias(sym: TermSymbol)(implicit ctx: Context): Annotation =
       apply(defn.AliasAnnot, List(
         ref(TermRef(sym.owner.thisType, sym.name, sym))))
 
@@ -176,11 +177,11 @@ object Annotations {
         else None
     }
 
-    def makeSourceFile(path: String)(implicit ctx: Context) =
+    def makeSourceFile(path: String)(implicit ctx: Context): Annotation =
       apply(defn.SourceFileAnnot, Literal(Constant(path)))
   }
 
-  def ThrowsAnnotation(cls: ClassSymbol)(implicit ctx: Context) = {
+  def ThrowsAnnotation(cls: ClassSymbol)(implicit ctx: Context): Annotation = {
     val tref = cls.typeRef
     Annotation(defn.ThrowsAnnotType.appliedTo(tref), Ident(tref))
   }
@@ -190,20 +191,20 @@ object Annotations {
    */
   implicit class AnnotInfo(val sym: Symbol) extends AnyVal {
 
-    def isDeprecated(implicit ctx: Context) =
+    def isDeprecated(implicit ctx: Context): Boolean =
       sym.hasAnnotation(defn.DeprecatedAnnot)
 
-    def deprecationMessage(implicit ctx: Context) =
+    def deprecationMessage(implicit ctx: Context): Option[String] =
       for (annot <- sym.getAnnotation(defn.DeprecatedAnnot);
            arg <- annot.argumentConstant(0))
       yield arg.stringValue
 
-    def migrationVersion(implicit ctx: Context) =
+    def migrationVersion(implicit ctx: Context): Option[Try[ScalaVersion]] =
       for (annot <- sym.getAnnotation(defn.MigrationAnnot);
            arg <- annot.argumentConstant(1))
       yield ScalaVersion.parse(arg.stringValue)
 
-    def migrationMessage(implicit ctx: Context) =
+    def migrationMessage(implicit ctx: Context): Option[Try[ScalaVersion]] =
       for (annot <- sym.getAnnotation(defn.MigrationAnnot);
            arg <- annot.argumentConstant(0))
       yield ScalaVersion.parse(arg.stringValue)
diff --git a/compiler/src/dotty/tools/dotc/core/CheckRealizable.scala b/compiler/src/dotty/tools/dotc/core/CheckRealizable.scala
index 48c842a284f5..bd4f77fae23a 100644
--- a/compiler/src/dotty/tools/dotc/core/CheckRealizable.scala
+++ b/compiler/src/dotty/tools/dotc/core/CheckRealizable.scala
@@ -2,22 +2,18 @@ package dotty.tools
 package dotc
 package core
 
-import Contexts._, Types._, Symbols._, Names._, Flags._, Scopes._
-import SymDenotations._, Denotations.SingleDenotation
-import util.Positions._
+import Contexts._, Types._, Symbols._, Names._, Flags._
+import Denotations.SingleDenotation
 import Decorators._
-import StdNames._
-import Annotations._
 import collection.mutable
-import ast.tpd._
 
 /** Realizability status */
 object CheckRealizable {
 
   abstract class Realizability(val msg: String) {
-    def andAlso(other: => Realizability) =
+    def andAlso(other: => Realizability): Realizability =
       if (this == Realizable) other else this
-    def mapError(f: Realizability => Realizability) =
+    def mapError(f: Realizability => Realizability): Realizability =
       if (this == Realizable) this else f(this)
   }
 
@@ -47,10 +43,10 @@ object CheckRealizable {
     assert(problem != Realizable)
   }
 
-  def realizability(tp: Type)(implicit ctx: Context) =
+  def realizability(tp: Type)(implicit ctx: Context): Realizability =
     new CheckRealizable().realizability(tp)
 
-  def boundsRealizability(tp: Type)(implicit ctx: Context) =
+  def boundsRealizability(tp: Type)(implicit ctx: Context): Realizability =
     new CheckRealizable().boundsRealizability(tp)
 
   private val LateInitialized = Lazy | Erased,
diff --git a/compiler/src/dotty/tools/dotc/core/Comments.scala b/compiler/src/dotty/tools/dotc/core/Comments.scala
index d372423e9e66..6bb489550012 100644
--- a/compiler/src/dotty/tools/dotc/core/Comments.scala
+++ b/compiler/src/dotty/tools/dotc/core/Comments.scala
@@ -12,7 +12,7 @@ import parsing.Parsers.Parser
 import reporting.diagnostic.messages.ProperDefinitionNotFound
 
 object Comments {
-  val ContextDoc = new Key[ContextDocstrings]
+  val ContextDoc: Key[ContextDocstrings] = new Key[ContextDocstrings]
 
   /** Decorator for getting docbase out of context */
   implicit class CommentsContext(val ctx: Context) extends AnyVal {
@@ -26,7 +26,7 @@ object Comments {
 
     private[this] val _docstrings: MutableSymbolMap[Comment] = newMutableSymbolMap
 
-    val templateExpander = new CommentExpander
+    val templateExpander: CommentExpander = new CommentExpander
 
     def docstrings: Map[Symbol, Comment] = _docstrings.toMap
 
@@ -54,7 +54,7 @@ object Comments {
     lazy val expandedBody: Option[String] =
       expanded.map(removeSections(_, "@usecase", "@define"))
 
-    val isDocComment = Comment.isDocComment(raw)
+    val isDocComment: Boolean = Comment.isDocComment(raw)
 
     /**
      * Expands this comment by giving its content to `f`, and then parsing the `@usecase` sections.
@@ -398,7 +398,7 @@ object Comments {
       expandInternal(initialStr, 0).replaceAllLiterally("""\$""", "$")
     }
 
-    def defineVariables(sym: Symbol)(implicit ctx: Context) = {
+    def defineVariables(sym: Symbol)(implicit ctx: Context): Unit = {
       val Trim = "(?s)^[\\s&&[^\n\r]]*(.*?)\\s*$".r
 
       val raw = ctx.docCtx.flatMap(_.docstring(sym).map(_.raw)).getOrElse("")
diff --git a/compiler/src/dotty/tools/dotc/core/Constants.scala b/compiler/src/dotty/tools/dotc/core/Constants.scala
index 38cdac21d7fe..048fca394c95 100644
--- a/compiler/src/dotty/tools/dotc/core/Constants.scala
+++ b/compiler/src/dotty/tools/dotc/core/Constants.scala
@@ -3,6 +3,7 @@ package core
 
 import Types._, Symbols._, Contexts._
 import printing.Printer
+import printing.Texts.Text
 
 object Constants {
 
@@ -27,15 +28,15 @@ object Constants {
     import java.lang.Double.doubleToRawLongBits
     import java.lang.Float.floatToRawIntBits
 
-    def isByteRange: Boolean  = isIntRange && Byte.MinValue <= intValue && intValue <= Byte.MaxValue
-    def isShortRange: Boolean = isIntRange && Short.MinValue <= intValue && intValue <= Short.MaxValue
-    def isCharRange: Boolean  = isIntRange && Char.MinValue <= intValue && intValue <= Char.MaxValue
-    def isIntRange: Boolean   = ByteTag <= tag && tag <= IntTag
-    def isLongRange: Boolean  = ByteTag <= tag && tag <= LongTag
-    def isFloatRange: Boolean = ByteTag <= tag && tag <= FloatTag
-    def isNumeric: Boolean    = ByteTag <= tag && tag <= DoubleTag
-    def isNonUnitAnyVal       = BooleanTag <= tag && tag <= DoubleTag
-    def isAnyVal              = UnitTag <= tag && tag <= DoubleTag
+    def isByteRange: Boolean     = isIntRange && Byte.MinValue <= intValue && intValue <= Byte.MaxValue
+    def isShortRange: Boolean    = isIntRange && Short.MinValue <= intValue && intValue <= Short.MaxValue
+    def isCharRange: Boolean     = isIntRange && Char.MinValue <= intValue && intValue <= Char.MaxValue
+    def isIntRange: Boolean      = ByteTag <= tag && tag <= IntTag
+    def isLongRange: Boolean     = ByteTag <= tag && tag <= LongTag
+    def isFloatRange: Boolean    = ByteTag <= tag && tag <= FloatTag
+    def isNumeric: Boolean       = ByteTag <= tag && tag <= DoubleTag
+    def isNonUnitAnyVal: Boolean = BooleanTag <= tag && tag <= DoubleTag
+    def isAnyVal: Boolean        = UnitTag <= tag && tag <= DoubleTag
 
     def tpe(implicit ctx: Context): Type = tag match {
       case UnitTag        => defn.UnitType
@@ -62,7 +63,7 @@ object Constants {
       case _ => false
     }
 
-    def isNaN = value match {
+    def isNaN: Boolean = value match {
       case f: Float  => f.isNaN
       case d: Double => d.isNaN
       case _ => false
@@ -188,7 +189,7 @@ object Constants {
 
     def stringValue: String = value.toString
 
-    def toText(printer: Printer) = printer.toText(this)
+    def toText(printer: Printer): Text = printer.toText(this)
 
     def typeValue: Type     = value.asInstanceOf[Type]
     def symbolValue: Symbol = value.asInstanceOf[Symbol]
@@ -219,29 +220,29 @@ object Constants {
       finalizeHash(h, length = 2)
     }
 
-    override def toString = s"Constant($value)"
-    def canEqual(x: Any) = true
-    def get     = value
-    def isEmpty = false
-    def _1      = value
+    override def toString: String = s"Constant($value)"
+    def canEqual(x: Any): Boolean = true
+    def get: Any                  = value
+    def isEmpty: Boolean          = false
+    def _1: Any                   = value
   }
 
   object Constant {
-    def apply(x: Null)         = new Constant(x, NullTag)
-    def apply(x: Unit)         = new Constant(x, UnitTag)
-    def apply(x: Boolean)      = new Constant(x, BooleanTag)
-    def apply(x: Byte)         = new Constant(x, ByteTag)
-    def apply(x: Short)        = new Constant(x, ShortTag)
-    def apply(x: Int)          = new Constant(x, IntTag)
-    def apply(x: Long)         = new Constant(x, LongTag)
-    def apply(x: Float)        = new Constant(x, FloatTag)
-    def apply(x: Double)       = new Constant(x, DoubleTag)
-    def apply(x: String)       = new Constant(x, StringTag)
-    def apply(x: Char)         = new Constant(x, CharTag)
-    def apply(x: Type)         = new Constant(x, ClazzTag)
-    def apply(x: Symbol)       = new Constant(x, EnumTag)
-    def apply(x: scala.Symbol) = new Constant(x, ScalaSymbolTag)
-    def apply(value: Any)      =
+    def apply(x: Null): Constant         = new Constant(x, NullTag)
+    def apply(x: Unit): Constant         = new Constant(x, UnitTag)
+    def apply(x: Boolean): Constant      = new Constant(x, BooleanTag)
+    def apply(x: Byte): Constant         = new Constant(x, ByteTag)
+    def apply(x: Short): Constant        = new Constant(x, ShortTag)
+    def apply(x: Int): Constant          = new Constant(x, IntTag)
+    def apply(x: Long): Constant         = new Constant(x, LongTag)
+    def apply(x: Float): Constant        = new Constant(x, FloatTag)
+    def apply(x: Double): Constant       = new Constant(x, DoubleTag)
+    def apply(x: String): Constant       = new Constant(x, StringTag)
+    def apply(x: Char): Constant         = new Constant(x, CharTag)
+    def apply(x: Type): Constant         = new Constant(x, ClazzTag)
+    def apply(x: Symbol): Constant       = new Constant(x, EnumTag)
+    def apply(x: scala.Symbol): Constant = new Constant(x, ScalaSymbolTag)
+    def apply(value: Any): Constant      =
       new Constant(value,
         value match {
           case null            => NullTag
@@ -261,6 +262,6 @@ object Constants {
         }
       )
 
-    def unapply(c: Constant) = c
+    def unapply(c: Constant): Constant = c
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/Constraint.scala b/compiler/src/dotty/tools/dotc/core/Constraint.scala
index 02d4fc1dd5b9..946a19b24d30 100644
--- a/compiler/src/dotty/tools/dotc/core/Constraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/Constraint.scala
@@ -2,12 +2,8 @@ package dotty.tools
 package dotc
 package core
 
-import Types._, Contexts._, Symbols._
-import collection.mutable
-import printing.{Printer, Showable}
-import printing.Texts._
-import config.Config
-import config.Printers.constr
+import Types._, Contexts._
+import printing.Showable
 
 /** Constraint over undetermined type parameters. Constraints are built
  *  over values of the following types:
diff --git a/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala b/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala
index 87a168f26580..aff9883cf294 100644
--- a/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala
+++ b/compiler/src/dotty/tools/dotc/core/ConstraintHandling.scala
@@ -6,8 +6,6 @@ import Types._, Contexts._, Symbols._
 import Decorators._
 import config.Config
 import config.Printers.{constr, typr}
-import TypeApplications.{EtaExpansion, TypeParamInfo}
-import collection.mutable
 
 /** Methods for adding constraints and solving them.
  *
@@ -33,7 +31,7 @@ trait ConstraintHandling {
   private[this] var addConstraintInvocations = 0
 
   /** If the constraint is frozen we cannot add new bounds to the constraint. */
-  protected var frozenConstraint = false
+  protected var frozenConstraint: Boolean = false
 
   /** Potentially a type lambda that is still instantiatable, even though the constraint
    *  is generally frozen.
@@ -45,7 +43,7 @@ trait ConstraintHandling {
    *  Aligning means computing `S1 =:= S2` which may change the current constraint.
    *  See note in TypeComparer#distributeAnd.
    */
-  protected var homogenizeArgs = false
+  protected var homogenizeArgs: Boolean = false
 
   /** We are currently comparing type lambdas. Used as a flag for
    *  optimization: when `false`, no need to do an expensive `pruneLambdaParams`
diff --git a/compiler/src/dotty/tools/dotc/core/ConstraintRunInfo.scala b/compiler/src/dotty/tools/dotc/core/ConstraintRunInfo.scala
index 73924d0cf19d..e6caae72bdde 100644
--- a/compiler/src/dotty/tools/dotc/core/ConstraintRunInfo.scala
+++ b/compiler/src/dotty/tools/dotc/core/ConstraintRunInfo.scala
@@ -7,14 +7,14 @@ import config.Printers.{default, typr}
 trait ConstraintRunInfo { self: Run =>
   private[this] var maxSize = 0
   private[this] var maxConstraint: Constraint = _
-  def recordConstraintSize(c: Constraint, size: Int) =
+  def recordConstraintSize(c: Constraint, size: Int): Unit =
     if (size > maxSize) {
       maxSize = size
       maxConstraint = c
     }
-  def printMaxConstraint()(implicit ctx: Context) = {
+  def printMaxConstraint()(implicit ctx: Context): Unit = {
     val printer = if (ctx.settings.YdetailedStats.value) default else typr
     if (maxSize > 0) printer.println(s"max constraint = ${maxConstraint.show}")
   }
-  protected def reset() = maxConstraint = null
+  protected def reset(): Unit = maxConstraint = null
 }
diff --git a/compiler/src/dotty/tools/dotc/core/Contexts.scala b/compiler/src/dotty/tools/dotc/core/Contexts.scala
index a80d25e16b04..7ea68b0ae816 100644
--- a/compiler/src/dotty/tools/dotc/core/Contexts.scala
+++ b/compiler/src/dotty/tools/dotc/core/Contexts.scala
@@ -10,11 +10,7 @@ import Phases._
 import Types._
 import Symbols._
 import Scopes._
-import NameOps._
 import Uniques._
-import SymDenotations._
-import Comments._
-import util.Positions._
 import ast.Trees._
 import ast.untpd
 import util.{FreshNameCreator, NoSource, SimpleIdentityMap, SourceFile}
@@ -25,13 +21,11 @@ import config.Config
 import reporting._
 import reporting.diagnostic.Message
 import collection.mutable
-import collection.immutable.BitSet
 import printing._
-import config.{JavaPlatform, Platform, ScalaSettings, Settings}
+import config.{JavaPlatform, Platform, ScalaSettings}
 
 import scala.annotation.internal.sharable
 
-import language.implicitConversions
 import DenotTransformers.DenotTransformer
 import dotty.tools.dotc.profile.Profiler
 import util.Property.Key
@@ -87,7 +81,7 @@ object Contexts {
     val base: ContextBase
 
     /** All outer contexts, ending in `base.initialCtx` and then `NoContext` */
-    def outersIterator = new Iterator[Context] {
+    def outersIterator: Iterator[Context] = new Iterator[Context] {
       var current = thiscontext
       def hasNext = current != NoContext
       def next = { val c = current; current = current.outer; c }
@@ -95,12 +89,12 @@ object Contexts {
 
     /** The outer context */
     private[this] var _outer: Context = _
-    protected def outer_=(outer: Context) = _outer = outer
+    protected def outer_=(outer: Context): Unit = _outer = outer
     def outer: Context = _outer
 
     /** The current context */
     private[this] var _period: Period = _
-    protected def period_=(period: Period) = {
+    protected def period_=(period: Period): Unit = {
       assert(period.firstPhaseId == period.lastPhaseId, period)
       _period = period
     }
@@ -108,54 +102,54 @@ object Contexts {
 
     /** The scope nesting level */
     private[this] var _mode: Mode = _
-    protected def mode_=(mode: Mode) = _mode = mode
+    protected def mode_=(mode: Mode): Unit = _mode = mode
     def mode: Mode = _mode
 
     /** The current owner symbol */
     private[this] var _owner: Symbol = _
-    protected def owner_=(owner: Symbol) = _owner = owner
+    protected def owner_=(owner: Symbol): Unit = _owner = owner
     def owner: Symbol = _owner
 
     /** The current tree */
     private[this] var _tree: Tree[_ >: Untyped]= _
-    protected def tree_=(tree: Tree[_ >: Untyped]) = _tree = tree
+    protected def tree_=(tree: Tree[_ >: Untyped]): Unit = _tree = tree
     def tree: Tree[_ >: Untyped] = _tree
 
     /** The current scope */
     private[this] var _scope: Scope = _
-    protected def scope_=(scope: Scope) = _scope = scope
+    protected def scope_=(scope: Scope): Unit = _scope = scope
     def scope: Scope = _scope
 
     /** The current type comparer */
     private[this] var _typerState: TyperState = _
-    protected def typerState_=(typerState: TyperState) = _typerState = typerState
+    protected def typerState_=(typerState: TyperState): Unit = _typerState = typerState
     def typerState: TyperState = _typerState
 
     /** The current type assigner or typer */
     private[this] var _typeAssigner: TypeAssigner = _
-    protected def typeAssigner_=(typeAssigner: TypeAssigner) = _typeAssigner = typeAssigner
+    protected def typeAssigner_=(typeAssigner: TypeAssigner): Unit = _typeAssigner = typeAssigner
     def typeAssigner: TypeAssigner = _typeAssigner
 
     /** The currently active import info */
     private[this] var _importInfo: ImportInfo = _
-    protected def importInfo_=(importInfo: ImportInfo) = _importInfo = importInfo
+    protected def importInfo_=(importInfo: ImportInfo): Unit = _importInfo = importInfo
     def importInfo: ImportInfo = _importInfo
 
     /** The current bounds in force for type parameters appearing in a GADT */
     private[this] var _gadt: GADTMap = _
-    protected def gadt_=(gadt: GADTMap) = _gadt = gadt
+    protected def gadt_=(gadt: GADTMap): Unit = _gadt = gadt
     def gadt: GADTMap = _gadt
 
     /** The history of implicit searches that are currently active */
     private[this] var _searchHistory: SearchHistory = null
-    protected def searchHistory_= (searchHistory: SearchHistory) = _searchHistory = searchHistory
+    protected def searchHistory_= (searchHistory: SearchHistory): Unit = _searchHistory = searchHistory
     def searchHistory: SearchHistory = _searchHistory
 
     /** The current type comparer. This ones updates itself automatically for
      *  each new context.
      */
     private[this] var _typeComparer: TypeComparer = _
-    protected def typeComparer_=(typeComparer: TypeComparer) = _typeComparer = typeComparer
+    protected def typeComparer_=(typeComparer: TypeComparer): Unit = _typeComparer = typeComparer
     def typeComparer: TypeComparer = {
       if (_typeComparer.ctx ne this)
         _typeComparer = _typeComparer.copyIn(this)
@@ -166,7 +160,7 @@ object Contexts {
      *  Typically used for attributes that are read and written only in special situations.
      */
     private[this] var _moreProperties: Map[Key[Any], Any] = _
-    protected def moreProperties_=(moreProperties: Map[Key[Any], Any]) = _moreProperties = moreProperties
+    protected def moreProperties_=(moreProperties: Map[Key[Any], Any]): Unit = _moreProperties = moreProperties
     def moreProperties: Map[Key[Any], Any] = _moreProperties
 
     def property[T](key: Key[T]): Option[T] =
@@ -178,7 +172,7 @@ object Contexts {
      *  slightly slower than a normal field access would be.
      */
     private var _store: Store = _
-    protected def store_=(store: Store) = _store = store
+    protected def store_=(store: Store): Unit = _store = store
     def store: Store = _store
 
     /** The compiler callback implementation, or null if no callback will be called. */
@@ -258,10 +252,10 @@ object Contexts {
     final def withPhase(phase: Phase): Context =
       withPhase(phase.id)
 
-    final def withPhaseNoLater(phase: Phase) =
+    final def withPhaseNoLater(phase: Phase): Context =
       if (phase.exists && ctx.phase.id > phase.id) withPhase(phase) else ctx
 
-    final def withPhaseNoEarlier(phase: Phase) =
+    final def withPhaseNoEarlier(phase: Phase): Context =
       if (phase.exists && ctx.phase.id < phase.id) withPhase(phase) else ctx
 
     // `creationTrace`-related code. To enable, uncomment the code below and the
@@ -371,13 +365,13 @@ object Contexts {
     }
 
     /** The context of expression `expr` seen as a member of a statement sequence */
-    def exprContext(stat: Tree[_ >: Untyped], exprOwner: Symbol) =
+    def exprContext(stat: Tree[_ >: Untyped], exprOwner: Symbol): Context =
       if (exprOwner == this.owner) this
       else if (untpd.isSuperConstrCall(stat) && this.owner.isClass) superCallContext
       else ctx.fresh.setOwner(exprOwner)
 
     /** A new context that summarizes an import statement */
-    def importContext(imp: Import[_], sym: Symbol) = {
+    def importContext(imp: Import[_], sym: Symbol): FreshContext = {
       val impNameOpt = imp.expr match {
         case ref: RefTree[_] => Some(ref.name.asTermName)
         case _               => None
@@ -427,37 +421,37 @@ object Contexts {
         case None => fresh.dropProperty(key)
       }
 
-    override def toString = {
+    override def toString: String = {
       def iinfo(implicit ctx: Context) = if (ctx.importInfo == null) "" else i"${ctx.importInfo.selectors}%, %"
       "Context(\n" +
       (outersIterator map ( ctx => s"  owner = ${ctx.owner}, scope = ${ctx.scope}, import = ${iinfo(ctx)}") mkString "\n")
     }
 
-    def typerPhase                  = base.typerPhase
-    def sbtExtractDependenciesPhase = base.sbtExtractDependenciesPhase
-    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)
+    def typerPhase: Phase                  = base.typerPhase
+    def sbtExtractDependenciesPhase: Phase = base.sbtExtractDependenciesPhase
+    def picklerPhase: Phase                = base.picklerPhase
+    def refchecksPhase: Phase              = base.refchecksPhase
+    def patmatPhase: Phase                 = base.patmatPhase
+    def elimRepeatedPhase: Phase           = base.elimRepeatedPhase
+    def extensionMethodsPhase: Phase       = base.extensionMethodsPhase
+    def explicitOuterPhase: Phase          = base.explicitOuterPhase
+    def gettersPhase: Phase                = base.gettersPhase
+    def erasurePhase: Phase                = base.erasurePhase
+    def elimErasedValueTypePhase: Phase    = base.elimErasedValueTypePhase
+    def lambdaLiftPhase: Phase             = base.lambdaLiftPhase
+    def flattenPhase: Phase                = base.flattenPhase
+    def genBCodePhase: Phase               = base.genBCodePhase
+    def phases: Array[Phase]               = base.phases
+
+    def settings: ScalaSettings            = base.settings
+    def definitions: Definitions           = base.definitions
+    def platform: Platform                 = base.platform
+    def pendingUnderlying: mutable.HashSet[Type]   = base.pendingUnderlying
+    def uniqueNamedTypes: Uniques.NamedTypeUniques = base.uniqueNamedTypes
+    def uniques: util.HashSet[Type]                = base.uniques
+    def nextId: Int                        = base.nextId
+
+    def initialize()(implicit ctx: Context): Unit = base.initialize()(ctx)
   }
 
   /** A condensed context provides only a small memory footprint over
@@ -529,7 +523,7 @@ object Contexts {
     def setSetting[T](setting: Setting[T], value: T): this.type =
       setSettings(setting.updateIn(settingsState, value))
 
-    def setDebug = setSetting(base.settings.Ydebug, true)
+    def setDebug: this.type = setSetting(base.settings.Ydebug, true)
   }
 
   implicit class ModeChanges(val c: Context) extends AnyVal {
@@ -566,7 +560,7 @@ object Contexts {
   }
 
   @sharable object NoContext extends Context {
-    val base = null
+    val base: ContextBase = null
     override val implicits: ContextualImplicits = new ContextualImplicits(Nil, null)(this)
   }
 
@@ -578,7 +572,7 @@ object Contexts {
                        with Phases.PhasesBase {
 
     /** The applicable settings */
-    val settings = new ScalaSettings
+    val settings: ScalaSettings = new ScalaSettings
 
     /** The initial context */
     val initialCtx: Context = new InitialContext(this, settings)
@@ -605,7 +599,7 @@ object Contexts {
     usePhases(List(SomePhase))
 
     /** The standard definitions */
-    val definitions = new Definitions
+    val definitions: Definitions = new Definitions
 
     /** Initializes the `ContextBase` with a starting context.
      *  This initializes the `platform` and the `definitions`.
@@ -625,22 +619,22 @@ object Contexts {
     // Symbols state
 
     /** A counter for unique ids */
-    private[core] var _nextId = 0
+    private[core] var _nextId: Int = 0
 
-    def nextId = { _nextId += 1; _nextId }
+    def nextId: Int = { _nextId += 1; _nextId }
 
     // Types state
     /** A table for hash consing unique types */
-    private[core] val uniques = new util.HashSet[Type](Config.initialUniquesCapacity) {
+    private[core] val uniques: util.HashSet[Type] = new util.HashSet[Type](Config.initialUniquesCapacity) {
       override def hash(x: Type): Int = x.hash
       override def isEqual(x: Type, y: Type) = x.eql(y)
     }
 
     /** A table for hash consing unique applied types */
-    private[dotc] val uniqueAppliedTypes = new AppliedUniques
+    private[dotc] val uniqueAppliedTypes: AppliedUniques = new AppliedUniques
 
     /** A table for hash consing unique named types */
-    private[core] val uniqueNamedTypes = new NamedTypeUniques
+    private[core] val uniqueNamedTypes: NamedTypeUniques = new NamedTypeUniques
 
     private def uniqueSets = Map(
         "uniques" -> uniques,
@@ -666,13 +660,13 @@ object Contexts {
 
     /** The set of named types on which a currently active invocation
      *  of underlying during a controlled operation exists. */
-    private[core] val pendingUnderlying = new mutable.HashSet[Type]
+    private[core] val pendingUnderlying: mutable.HashSet[Type] = new mutable.HashSet[Type]
 
     /** A map from ErrorType to associated message computation. We use this map
      *  instead of storing message computations directly in ErrorTypes in order
      *  to avoid space leaks - the message computation usually captures a context.
      */
-    private[core] val errorTypeMsg = mutable.Map[ErrorType, () => Message]()
+    private[core] val errorTypeMsg: mutable.Map[Types.ErrorType, () => Message] = mutable.Map()
 
     // Phases state
 
@@ -691,14 +685,14 @@ object Contexts {
 
     // Printers state
     /** Number of recursive invocations of a show method on current stack */
-    private[dotc] var toTextRecursions = 0
+    private[dotc] var toTextRecursions: Int = 0
 
     // Reporters state
-    private[dotc] var indent = 0
+    private[dotc] var indent: Int = 0
 
-    protected[dotc] val indentTab = "  "
+    protected[dotc] val indentTab: String = "  "
 
-    def reset() = {
+    def reset(): Unit = {
       for ((_, set) <- uniqueSets) set.clear()
       errorTypeMsg.clear()
     }
@@ -709,7 +703,7 @@ object Contexts {
     @sharable private[this] var thread: Thread = null
 
     /** Check that we are on the same thread as before */
-    def checkSingleThreaded() =
+    def checkSingleThreaded(): Unit =
       if (thread == null) thread = Thread.currentThread()
       else assert(thread == Thread.currentThread(), "illegal multithreaded access to ContextBase")
   }
@@ -718,10 +712,10 @@ object Contexts {
     private[this] var myBounds = initBounds
     def setBounds(sym: Symbol, b: TypeBounds): Unit =
       myBounds = myBounds.updated(sym, b)
-    def bounds = myBounds
+    def bounds: SimpleIdentityMap[Symbol, TypeBounds] = myBounds
   }
 
   @sharable object EmptyGADTMap extends GADTMap(SimpleIdentityMap.Empty) {
-    override def setBounds(sym: Symbol, b: TypeBounds) = unsupported("EmptyGADTMap.setBounds")
+    override def setBounds(sym: Symbol, b: TypeBounds): Unit = unsupported("EmptyGADTMap.setBounds")
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/Decorators.scala b/compiler/src/dotty/tools/dotc/core/Decorators.scala
index 4343d2bb0ad9..95b55ac14632 100644
--- a/compiler/src/dotty/tools/dotc/core/Decorators.scala
+++ b/compiler/src/dotty/tools/dotc/core/Decorators.scala
@@ -3,7 +3,7 @@ package core
 
 import annotation.tailrec
 import Symbols._
-import Contexts._, Names._, Phases._, printing.Texts._, printing.Printer, printing.Showable
+import Contexts._, Names._, Phases._, printing.Texts._, printing.Printer
 import util.Positions.Position, util.SourcePosition
 import collection.mutable.ListBuffer
 import dotty.tools.dotc.transform.MegaPhase
@@ -143,7 +143,7 @@ object Decorators {
   }
 
   implicit class TextToString(val text: Text) extends AnyVal {
-    def show(implicit ctx: Context) = text.mkString(ctx.settings.pageWidth.value, ctx.settings.printLines.value)
+    def show(implicit ctx: Context): String = text.mkString(ctx.settings.pageWidth.value, ctx.settings.printLines.value)
   }
 
   /** Test whether a list of strings representing phases contains
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index d43611c53f52..05f599297e26 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -2,20 +2,19 @@ package dotty.tools
 package dotc
 package core
 
-import Types._, Contexts._, Symbols._, Denotations._, SymDenotations._, StdNames._, Names._
-import Flags._, Scopes._, Decorators._, NameOps._, util.Positions._, Periods._
+import Types._, Contexts._, Symbols._, SymDenotations._, StdNames._, Names._
+import Flags._, Scopes._, Decorators._, NameOps._, Periods._
 import unpickleScala2.Scala2Unpickler.ensureConstructor
-import scala.collection.{ mutable, immutable }
-import PartialFunction._
+import scala.collection.mutable
 import collection.mutable
-import util.common.alwaysZero
+import Denotations.SingleDenotation
 
 object Definitions {
 
   /** The maximum number of elements in a tuple or product.
    *  This should be removed once we go to hlists.
    */
-  val MaxTupleArity = 22
+  val MaxTupleArity: Int = 22
 
   /** The maximum arity N of a function type that's implemented
    *  as a trait `scala.FunctionN`. Functions of higher arity are possible,
@@ -24,10 +23,10 @@ object Definitions {
    *  The limit 22 is chosen for Scala2x interop. It could be something
    *  else without affecting the set of programs that can be compiled.
    */
-  val MaxImplementedFunctionArity = 22
+  val MaxImplementedFunctionArity: Int = 22
 
   /** The maximal arity of a function that can be accessed as member of a structural type */
-  val MaxStructuralMethodArity = 7
+  val MaxStructuralMethodArity: Int = 7
 }
 
 /** A class defining symbols and types of standard definitions
@@ -192,17 +191,17 @@ class Definitions {
   lazy val RootPackage: TermSymbol = ctx.newSymbol(
     NoSymbol, nme.ROOTPKG, PackageCreationFlags, TypeRef(NoPrefix, RootClass))
 
-  lazy val EmptyPackageVal = ctx.newPackageSymbol(
+  lazy val EmptyPackageVal: TermSymbol = ctx.newPackageSymbol(
     RootClass, nme.EMPTY_PACKAGE, (emptypkg, emptycls) => ctx.base.rootLoader(emptypkg)).entered
-  lazy val EmptyPackageClass = EmptyPackageVal.moduleClass.asClass
+  lazy val EmptyPackageClass: ClassSymbol = 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 OpsPackageVal: TermSymbol = ctx.newCompletePackageSymbol(RootClass, nme.OPS_PACKAGE).entered
+  lazy val OpsPackageClass: ClassSymbol = OpsPackageVal.moduleClass.asClass
 
-  lazy val ScalaPackageVal = ctx.requiredPackage(nme.scala_)
-  lazy val ScalaMathPackageVal = ctx.requiredPackage("scala.math")
-  lazy val ScalaPackageClass = {
+  lazy val ScalaPackageVal: TermSymbol = ctx.requiredPackage(nme.scala_)
+  lazy val ScalaMathPackageVal: TermSymbol = ctx.requiredPackage("scala.math")
+  lazy val ScalaPackageClass: ClassSymbol = {
     val cls = ScalaPackageVal.moduleClass.asClass
     cls.info.decls.openForMutations.useSynthesizer(
       name => ctx =>
@@ -210,22 +209,22 @@ class Definitions {
         else NoSymbol)
     cls
   }
-  lazy val ScalaPackageObjectRef = ctx.requiredModuleRef("scala.package")
-  lazy val JavaPackageVal = ctx.requiredPackage(nme.java)
-  lazy val JavaLangPackageVal = ctx.requiredPackage(jnme.JavaLang)
+  lazy val ScalaPackageObjectRef: TermRef = ctx.requiredModuleRef("scala.package")
+  lazy val JavaPackageVal: TermSymbol = ctx.requiredPackage(nme.java)
+  lazy val JavaLangPackageVal: TermSymbol = ctx.requiredPackage(jnme.JavaLang)
   // fundamental modules
-  lazy val SysPackage = ctx.requiredModule("scala.sys.package")
-    lazy val Sys_errorR = SysPackage.moduleClass.requiredMethodRef(nme.error)
-    def Sys_error(implicit ctx: Context) = Sys_errorR.symbol
-
-  lazy val TypelevelPackageObjectRef = ctx.requiredModuleRef("scala.typelevel.package")
-  lazy val TypelevelPackageObject = TypelevelPackageObjectRef.symbol.moduleClass
-    lazy val Typelevel_errorR = TypelevelPackageObjectRef.symbol.requiredMethodRef(nme.error)
-    def Typelevel_error(implicit ctx: Context) = Typelevel_errorR.symbol
-    lazy val Typelevel_constValueR = TypelevelPackageObjectRef.symbol.requiredMethodRef("constValue")
-    def Typelevel_constValue(implicit ctx: Context) = Typelevel_constValueR.symbol
-    lazy val Typelevel_constValueOptR = TypelevelPackageObjectRef.symbol.requiredMethodRef("constValueOpt")
-    def Typelevel_constValueOpt(implicit ctx: Context) = Typelevel_constValueOptR.symbol
+  lazy val SysPackage: TermSymbol = ctx.requiredModule("scala.sys.package")
+    lazy val Sys_errorR: TermRef = SysPackage.moduleClass.requiredMethodRef(nme.error)
+    def Sys_error(implicit ctx: Context): Symbol = Sys_errorR.symbol
+
+  lazy val TypelevelPackageObjectRef: TermRef = ctx.requiredModuleRef("scala.typelevel.package")
+  lazy val TypelevelPackageObject: Symbol = TypelevelPackageObjectRef.symbol.moduleClass
+    lazy val Typelevel_errorR: TermRef = TypelevelPackageObjectRef.symbol.requiredMethodRef(nme.error)
+    def Typelevel_error(implicit ctx: Context): Symbol = Typelevel_errorR.symbol
+    lazy val Typelevel_constValueR: TermRef = TypelevelPackageObjectRef.symbol.requiredMethodRef("constValue")
+    def Typelevel_constValue(implicit ctx: Context): Symbol = Typelevel_constValueR.symbol
+    lazy val Typelevel_constValueOptR: TermRef = TypelevelPackageObjectRef.symbol.requiredMethodRef("constValueOpt")
+    def Typelevel_constValueOpt(implicit ctx: Context): Symbol = Typelevel_constValueOptR.symbol
 
   /** The `scalaShadowing` package is used to safely modify classes and
    *  objects in scala so that they can be used from dotty. They will
@@ -234,8 +233,8 @@ class Definitions {
    *  in `scalaShadowing` so they don't clash with the same-named `scala`
    *  members at runtime.
    */
-  lazy val ScalaShadowingPackageVal = ctx.requiredPackage(nme.scalaShadowing)
-  def ScalaShadowingPackageClass(implicit ctx: Context) = ScalaShadowingPackageVal.moduleClass.asClass
+  lazy val ScalaShadowingPackageVal: TermSymbol = ctx.requiredPackage(nme.scalaShadowing)
+  def ScalaShadowingPackageClass(implicit ctx: Context): ClassSymbol = ScalaShadowingPackageVal.moduleClass.asClass
 
   /** Note: We cannot have same named methods defined in Object and Any (and AnyVal, for that matter)
    *  because after erasure the Any and AnyVal references get remapped to the Object methods
@@ -260,23 +259,23 @@ class Definitions {
    *     }
    */
   lazy val AnyClass: ClassSymbol = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.Any, Abstract, Nil))
-  def AnyType = AnyClass.typeRef
+  def AnyType: TypeRef = AnyClass.typeRef
   lazy val AnyValClass: ClassSymbol = completeClass(enterCompleteClassSymbol(ScalaPackageClass, tpnme.AnyVal, Abstract, List(AnyClass.typeRef)))
-  def AnyValType = AnyValClass.typeRef
-
-    lazy val Any_==       = enterMethod(AnyClass, nme.EQ, methOfAny(BooleanType), Final)
-    lazy val Any_!=       = enterMethod(AnyClass, nme.NE, methOfAny(BooleanType), Final)
-    lazy val Any_equals   = enterMethod(AnyClass, nme.equals_, methOfAny(BooleanType))
-    lazy val Any_hashCode = enterMethod(AnyClass, nme.hashCode_, MethodType(Nil, IntType))
-    lazy val Any_toString = enterMethod(AnyClass, nme.toString_, MethodType(Nil, StringType))
-    lazy val Any_##       = enterMethod(AnyClass, nme.HASHHASH, ExprType(IntType), Final)
-    lazy val Any_getClass = enterMethod(AnyClass, nme.getClass_, MethodType(Nil, ClassClass.typeRef.appliedTo(TypeBounds.empty)), Final)
-    lazy val Any_isInstanceOf = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOf_, _ => BooleanType, Final)
-    lazy val Any_asInstanceOf = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, _.paramRefs(0), Final)
-    lazy val Any_typeTest = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOfPM, _ => BooleanType, Final | Synthetic)
+  def AnyValType: TypeRef = AnyValClass.typeRef
+
+    lazy val Any_== : TermSymbol       = enterMethod(AnyClass, nme.EQ, methOfAny(BooleanType), Final)
+    lazy val Any_!= : TermSymbol       = enterMethod(AnyClass, nme.NE, methOfAny(BooleanType), Final)
+    lazy val Any_equals: TermSymbol   = enterMethod(AnyClass, nme.equals_, methOfAny(BooleanType))
+    lazy val Any_hashCode: TermSymbol = enterMethod(AnyClass, nme.hashCode_, MethodType(Nil, IntType))
+    lazy val Any_toString: TermSymbol = enterMethod(AnyClass, nme.toString_, MethodType(Nil, StringType))
+    lazy val Any_## : TermSymbol       = enterMethod(AnyClass, nme.HASHHASH, ExprType(IntType), Final)
+    lazy val Any_getClass: TermSymbol = enterMethod(AnyClass, nme.getClass_, MethodType(Nil, ClassClass.typeRef.appliedTo(TypeBounds.empty)), Final)
+    lazy val Any_isInstanceOf: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOf_, _ => BooleanType, Final)
+    lazy val Any_asInstanceOf: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.asInstanceOf_, _.paramRefs(0), Final)
+    lazy val Any_typeTest: TermSymbol = enterT1ParameterlessMethod(AnyClass, nme.isInstanceOfPM, _ => BooleanType, Final | Synthetic)
       // generated by pattern matcher, eliminated by erasure
 
-    def AnyMethods = List(Any_==, Any_!=, Any_equals, Any_hashCode,
+    def AnyMethods: List[TermSymbol] = List(Any_==, Any_!=, Any_equals, Any_hashCode,
       Any_toString, Any_##, Any_getClass, Any_isInstanceOf, Any_asInstanceOf, Any_typeTest)
 
   lazy val ObjectClass: ClassSymbol = {
@@ -293,27 +292,27 @@ class Definitions {
 
     completeClass(cls)
   }
-  def ObjectType = ObjectClass.typeRef
+  def ObjectType: TypeRef = ObjectClass.typeRef
 
   lazy val AnyRefAlias: TypeSymbol = enterAliasType(tpnme.AnyRef, ObjectType)
-  def AnyRefType = AnyRefAlias.typeRef
+  def AnyRefType: TypeRef = AnyRefAlias.typeRef
 
-    lazy val Object_eq = enterMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final)
-    lazy val Object_ne = enterMethod(ObjectClass, nme.ne, methOfAnyRef(BooleanType), Final)
-    lazy val Object_synchronized = enterPolyMethod(ObjectClass, nme.synchronized_, 1,
+    lazy val Object_eq: TermSymbol = enterMethod(ObjectClass, nme.eq, methOfAnyRef(BooleanType), Final)
+    lazy val Object_ne: TermSymbol = enterMethod(ObjectClass, nme.ne, methOfAnyRef(BooleanType), Final)
+    lazy val Object_synchronized: TermSymbol = enterPolyMethod(ObjectClass, nme.synchronized_, 1,
         pt => MethodType(List(pt.paramRefs(0)), pt.paramRefs(0)), Final)
-    lazy val Object_clone = enterMethod(ObjectClass, nme.clone_, MethodType(Nil, ObjectType), Protected)
-    lazy val Object_finalize = enterMethod(ObjectClass, nme.finalize_, MethodType(Nil, UnitType), Protected)
-    lazy val Object_notify = enterMethod(ObjectClass, nme.notify_, MethodType(Nil, UnitType), Final)
-    lazy val Object_notifyAll = enterMethod(ObjectClass, nme.notifyAll_, MethodType(Nil, UnitType), Final)
-    lazy val Object_wait = enterMethod(ObjectClass, nme.wait_, MethodType(Nil, UnitType), Final)
-    lazy val Object_waitL = enterMethod(ObjectClass, nme.wait_, MethodType(LongType :: Nil, UnitType), Final)
-    lazy val Object_waitLI = enterMethod(ObjectClass, nme.wait_, MethodType(LongType :: IntType :: Nil, UnitType), Final)
-
-    def ObjectMethods = List(Object_eq, Object_ne, Object_synchronized, Object_clone,
+    lazy val Object_clone: TermSymbol = enterMethod(ObjectClass, nme.clone_, MethodType(Nil, ObjectType), Protected)
+    lazy val Object_finalize: TermSymbol = enterMethod(ObjectClass, nme.finalize_, MethodType(Nil, UnitType), Protected)
+    lazy val Object_notify: TermSymbol = enterMethod(ObjectClass, nme.notify_, MethodType(Nil, UnitType), Final)
+    lazy val Object_notifyAll: TermSymbol = enterMethod(ObjectClass, nme.notifyAll_, MethodType(Nil, UnitType), Final)
+    lazy val Object_wait: TermSymbol = enterMethod(ObjectClass, nme.wait_, MethodType(Nil, UnitType), Final)
+    lazy val Object_waitL: TermSymbol = enterMethod(ObjectClass, nme.wait_, MethodType(LongType :: Nil, UnitType), Final)
+    lazy val Object_waitLI: TermSymbol = enterMethod(ObjectClass, nme.wait_, MethodType(LongType :: IntType :: Nil, UnitType), Final)
+
+    def ObjectMethods: List[TermSymbol] = List(Object_eq, Object_ne, Object_synchronized, Object_clone,
         Object_finalize, Object_notify, Object_notifyAll, Object_wait, Object_waitL, Object_waitLI)
 
-  lazy val AnyKindClass = {
+  lazy val AnyKindClass: ClassSymbol = {
     val cls = ctx.newCompleteClassSymbol(ScalaPackageClass, tpnme.AnyKind, AbstractFinal | Permanent, Nil)
     if (ctx.settings.YkindPolymorphism.value) {
       // Enable kind-polymorphism by exposing scala.AnyKind
@@ -321,60 +320,60 @@ class Definitions {
     }
     cls
   }
-  def AnyKindType = AnyKindClass.typeRef
+  def AnyKindType: TypeRef = AnyKindClass.typeRef
 
   /** Marker method to indicate an argument to a call-by-name parameter.
    *  Created by byNameClosures and elimByName, eliminated by Erasure,
    */
-  lazy val cbnArg = enterPolyMethod(OpsPackageClass, nme.cbnArg, 1,
+  lazy val cbnArg: TermSymbol = enterPolyMethod(OpsPackageClass, nme.cbnArg, 1,
       pt => MethodType(List(FunctionOf(Nil, pt.paramRefs(0))), pt.paramRefs(0)))
 
   /** Method representing a throw */
-  lazy val throwMethod = enterMethod(OpsPackageClass, nme.THROWkw,
+  lazy val throwMethod: TermSymbol = enterMethod(OpsPackageClass, nme.THROWkw,
       MethodType(List(ThrowableType), NothingType))
 
   lazy val NothingClass: ClassSymbol = enterCompleteClassSymbol(
     ScalaPackageClass, tpnme.Nothing, AbstractFinal, List(AnyClass.typeRef))
-  def NothingType = NothingClass.typeRef
-  lazy val RuntimeNothingModuleRef = ctx.requiredModuleRef("scala.runtime.Nothing")
+  def NothingType: TypeRef = NothingClass.typeRef
+  lazy val RuntimeNothingModuleRef: TermRef = ctx.requiredModuleRef("scala.runtime.Nothing")
   lazy val NullClass: ClassSymbol = enterCompleteClassSymbol(
     ScalaPackageClass, tpnme.Null, AbstractFinal, 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
-    def Predef_Conforms(implicit ctx: Context) = Predef_ConformsR.symbol
-    lazy val Predef_conformsR = ScalaPredefModule.requiredMethodRef(nme.conforms_)
-    def Predef_conforms(implicit ctx: Context) = Predef_conformsR.symbol
-    lazy val Predef_classOfR = ScalaPredefModule.requiredMethodRef(nme.classOf)
-    def Predef_classOf(implicit ctx: Context) = Predef_classOfR.symbol
-    lazy val Predef_undefinedR = ScalaPredefModule.requiredMethodRef(nme.???)
-    def Predef_undefined(implicit ctx: Context) = Predef_undefinedR.symbol
-
-  lazy val ScalaRuntimeModuleRef = ctx.requiredModuleRef("scala.runtime.ScalaRunTime")
-  def ScalaRuntimeModule(implicit ctx: Context) = ScalaRuntimeModuleRef.symbol
-  def ScalaRuntimeClass(implicit ctx: Context) = ScalaRuntimeModule.moduleClass.asClass
-
-    def runtimeMethodRef(name: PreName) = ScalaRuntimeModule.requiredMethodRef(name)
-    def ScalaRuntime_dropR(implicit ctx: Context) = runtimeMethodRef(nme.drop)
-    def ScalaRuntime_drop(implicit ctx: Context) = ScalaRuntime_dropR.symbol
-
-  lazy val BoxesRunTimeModuleRef = ctx.requiredModuleRef("scala.runtime.BoxesRunTime")
-  def BoxesRunTimeModule(implicit ctx: Context) = BoxesRunTimeModuleRef.symbol
-  def BoxesRunTimeClass(implicit ctx: Context) = BoxesRunTimeModule.moduleClass.asClass
-  lazy val ScalaStaticsModuleRef = ctx.requiredModuleRef("scala.runtime.Statics")
-  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 NullType: TypeRef = NullClass.typeRef
+  lazy val RuntimeNullModuleRef: TermRef = ctx.requiredModuleRef("scala.runtime.Null")
+
+  lazy val ScalaPredefModuleRef: TermRef = ctx.requiredModuleRef("scala.Predef")
+  def ScalaPredefModule(implicit ctx: Context): Symbol = ScalaPredefModuleRef.symbol
+
+    lazy val Predef_ConformsR: TypeRef = ScalaPredefModule.requiredClass("<:<").typeRef
+    def Predef_Conforms(implicit ctx: Context): Symbol = Predef_ConformsR.symbol
+    lazy val Predef_conformsR: TermRef = ScalaPredefModule.requiredMethodRef(nme.conforms_)
+    def Predef_conforms(implicit ctx: Context): Symbol = Predef_conformsR.symbol
+    lazy val Predef_classOfR: TermRef = ScalaPredefModule.requiredMethodRef(nme.classOf)
+    def Predef_classOf(implicit ctx: Context): Symbol = Predef_classOfR.symbol
+    lazy val Predef_undefinedR: TermRef = ScalaPredefModule.requiredMethodRef(nme.???)
+    def Predef_undefined(implicit ctx: Context): Symbol = Predef_undefinedR.symbol
+
+  lazy val ScalaRuntimeModuleRef: TermRef = ctx.requiredModuleRef("scala.runtime.ScalaRunTime")
+  def ScalaRuntimeModule(implicit ctx: Context): Symbol = ScalaRuntimeModuleRef.symbol
+  def ScalaRuntimeClass(implicit ctx: Context): ClassSymbol = ScalaRuntimeModule.moduleClass.asClass
+
+    def runtimeMethodRef(name: PreName): TermRef = ScalaRuntimeModule.requiredMethodRef(name)
+    def ScalaRuntime_dropR(implicit ctx: Context): TermRef = runtimeMethodRef(nme.drop)
+    def ScalaRuntime_drop(implicit ctx: Context): Symbol = ScalaRuntime_dropR.symbol
+
+  lazy val BoxesRunTimeModuleRef: TermRef = ctx.requiredModuleRef("scala.runtime.BoxesRunTime")
+  def BoxesRunTimeModule(implicit ctx: Context): Symbol = BoxesRunTimeModuleRef.symbol
+  def BoxesRunTimeClass(implicit ctx: Context): ClassSymbol = BoxesRunTimeModule.moduleClass.asClass
+  lazy val ScalaStaticsModuleRef: TermRef = ctx.requiredModuleRef("scala.runtime.Statics")
+  def ScalaStaticsModule(implicit ctx: Context): Symbol = ScalaStaticsModuleRef.symbol
+  def ScalaStaticsClass(implicit ctx: Context): ClassSymbol = ScalaStaticsModule.moduleClass.asClass
+
+    def staticsMethodRef(name: PreName): TermRef = ScalaStaticsModule.requiredMethodRef(name)
+    def staticsMethod(name: PreName): 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.
-  def DottyPredefModuleRef = {
+  def DottyPredefModuleRef: TermRef = {
     if (myDottyPredefModuleRef == null) {
       myDottyPredefModuleRef = ctx.requiredModuleRef("dotty.DottyPredef")
       assert(myDottyPredefModuleRef != null)
@@ -383,29 +382,29 @@ class Definitions {
   }
   private[this] var myDottyPredefModuleRef: TermRef = _
 
-  def DottyPredefModule(implicit ctx: Context) = DottyPredefModuleRef.symbol
+  def DottyPredefModule(implicit ctx: Context): Symbol = DottyPredefModuleRef.symbol
 
-    lazy val Predef_ImplicitConverterR = DottyPredefModule.requiredClass("ImplicitConverter").typeRef
-    def Predef_ImplicitConverter(implicit ctx: Context) = Predef_ImplicitConverterR.symbol
+    lazy val Predef_ImplicitConverterR: TypeRef = DottyPredefModule.requiredClass("ImplicitConverter").typeRef
+    def Predef_ImplicitConverter(implicit ctx: Context): Symbol = 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")
+  lazy val DottyArraysModuleRef: TermRef = ctx.requiredModuleRef("dotty.runtime.Arrays")
+  def DottyArraysModule(implicit ctx: Context): Symbol = DottyArraysModuleRef.symbol
+    def newGenericArrayMethod(implicit ctx: Context): TermSymbol = DottyArraysModule.requiredMethod("newGenericArray")
+    def newArrayMethod(implicit ctx: Context): TermSymbol = DottyArraysModule.requiredMethod("newArray")
 
   // TODO: Remove once we drop support for 2.12 standard library
   private[this] lazy val isNewCollections = ctx.base.staticRef("scala.collection.IterableOnce".toTypeName).exists
 
-  def getWrapVarargsArrayModule = if (isNewCollections) ScalaRuntimeModule else ScalaPredefModule
+  def getWrapVarargsArrayModule: Symbol = if (isNewCollections) ScalaRuntimeModule else ScalaPredefModule
 
   // The set of all wrap{X, Ref}Array methods, where X is a value type
-  val WrapArrayMethods = new PerRun[collection.Set[Symbol]]({ implicit ctx =>
+  val WrapArrayMethods: PerRun[collection.Set[Symbol]] = new PerRun({ implicit ctx =>
     val methodNames = ScalaValueTypes.map(ast.tpd.wrapArrayMethodName) + nme.wrapRefArray
     methodNames.map(getWrapVarargsArrayModule.requiredMethodRef(_).symbol)
   })
 
-  lazy val NilModuleRef = ctx.requiredModuleRef("scala.collection.immutable.Nil")
-  def NilModule(implicit ctx: Context) = NilModuleRef.symbol
+  lazy val NilModuleRef: TermRef = ctx.requiredModuleRef("scala.collection.immutable.Nil")
+  def NilModule(implicit ctx: Context): Symbol = NilModuleRef.symbol
 
   lazy val SingletonClass: ClassSymbol =
     // needed as a synthetic class because Scala 2.x refers to it in classfiles
@@ -418,415 +417,415 @@ class Definitions {
   lazy val SeqType: TypeRef =
     if (isNewCollections) ctx.requiredClassRef("scala.collection.immutable.Seq")
     else ctx.requiredClassRef("scala.collection.Seq")
-  def SeqClass(implicit ctx: Context) = SeqType.symbol.asClass
-    lazy val Seq_applyR = SeqClass.requiredMethodRef(nme.apply)
-    def Seq_apply(implicit ctx: Context) = Seq_applyR.symbol
-    lazy val Seq_headR = SeqClass.requiredMethodRef(nme.head)
-    def Seq_head(implicit ctx: Context) = Seq_headR.symbol
-    lazy val Seq_dropR = SeqClass.requiredMethodRef(nme.drop)
-    def Seq_drop(implicit ctx: Context) = Seq_dropR.symbol
-    lazy val Seq_lengthCompareR = SeqClass.requiredMethodRef(nme.lengthCompare)
-    def Seq_lengthCompare(implicit ctx: Context) = Seq_lengthCompareR.symbol
-    lazy val Seq_lengthR = SeqClass.requiredMethodRef(nme.length)
-    def Seq_length(implicit ctx: Context) = Seq_lengthR.symbol
-    lazy val Seq_toSeqR = SeqClass.requiredMethodRef(nme.toSeq)
-    def Seq_toSeq(implicit ctx: Context) = Seq_toSeqR.symbol
+  def SeqClass(implicit ctx: Context): ClassSymbol = SeqType.symbol.asClass
+    lazy val Seq_applyR: TermRef = SeqClass.requiredMethodRef(nme.apply)
+    def Seq_apply(implicit ctx: Context): Symbol = Seq_applyR.symbol
+    lazy val Seq_headR: TermRef = SeqClass.requiredMethodRef(nme.head)
+    def Seq_head(implicit ctx: Context): Symbol = Seq_headR.symbol
+    lazy val Seq_dropR: TermRef = SeqClass.requiredMethodRef(nme.drop)
+    def Seq_drop(implicit ctx: Context): Symbol = Seq_dropR.symbol
+    lazy val Seq_lengthCompareR: TermRef = SeqClass.requiredMethodRef(nme.lengthCompare)
+    def Seq_lengthCompare(implicit ctx: Context): Symbol = Seq_lengthCompareR.symbol
+    lazy val Seq_lengthR: TermRef = SeqClass.requiredMethodRef(nme.length)
+    def Seq_length(implicit ctx: Context): Symbol = Seq_lengthR.symbol
+    lazy val Seq_toSeqR: TermRef = SeqClass.requiredMethodRef(nme.toSeq)
+    def Seq_toSeq(implicit ctx: Context): Symbol = Seq_toSeqR.symbol
 
   lazy val ArrayType: TypeRef = ctx.requiredClassRef("scala.Array")
-  def ArrayClass(implicit ctx: Context) = ArrayType.symbol.asClass
-    lazy val Array_applyR                 = ArrayClass.requiredMethodRef(nme.apply)
-    def Array_apply(implicit ctx: Context) = Array_applyR.symbol
-    lazy val Array_updateR                = ArrayClass.requiredMethodRef(nme.update)
-    def Array_update(implicit ctx: Context) = Array_updateR.symbol
-    lazy val Array_lengthR                = ArrayClass.requiredMethodRef(nme.length)
-    def Array_length(implicit ctx: Context) = Array_lengthR.symbol
-    lazy val Array_cloneR                 = ArrayClass.requiredMethodRef(nme.clone_)
-    def Array_clone(implicit ctx: Context) = Array_cloneR.symbol
-    lazy val ArrayConstructorR            = ArrayClass.requiredMethodRef(nme.CONSTRUCTOR)
-    def ArrayConstructor(implicit ctx: Context) = ArrayConstructorR.symbol
-  lazy val ArrayModuleType = ctx.requiredModuleRef("scala.Array")
-  def ArrayModule(implicit ctx: Context) = ArrayModuleType.symbol.moduleClass.asClass
+  def ArrayClass(implicit ctx: Context): ClassSymbol = ArrayType.symbol.asClass
+    lazy val Array_applyR: TermRef                 = ArrayClass.requiredMethodRef(nme.apply)
+    def Array_apply(implicit ctx: Context): Symbol = Array_applyR.symbol
+    lazy val Array_updateR: TermRef                = ArrayClass.requiredMethodRef(nme.update)
+    def Array_update(implicit ctx: Context): Symbol = Array_updateR.symbol
+    lazy val Array_lengthR: TermRef                = ArrayClass.requiredMethodRef(nme.length)
+    def Array_length(implicit ctx: Context): Symbol = Array_lengthR.symbol
+    lazy val Array_cloneR: TermRef                 = ArrayClass.requiredMethodRef(nme.clone_)
+    def Array_clone(implicit ctx: Context): Symbol = Array_cloneR.symbol
+    lazy val ArrayConstructorR: TermRef            = ArrayClass.requiredMethodRef(nme.CONSTRUCTOR)
+    def ArrayConstructor(implicit ctx: Context): Symbol = ArrayConstructorR.symbol
+  lazy val ArrayModuleType: TermRef = ctx.requiredModuleRef("scala.Array")
+  def ArrayModule(implicit ctx: Context): ClassSymbol = ArrayModuleType.symbol.moduleClass.asClass
 
 
   lazy val UnitType: TypeRef = valueTypeRef("scala.Unit", BoxedUnitType, java.lang.Void.TYPE, UnitEnc, nme.specializedTypeNames.Void)
-  def UnitClass(implicit ctx: Context) = UnitType.symbol.asClass
-  def UnitModuleClass(implicit ctx: Context) = UnitType.symbol.asClass.linkedClass
-  lazy val BooleanType = valueTypeRef("scala.Boolean", BoxedBooleanType, java.lang.Boolean.TYPE, BooleanEnc, nme.specializedTypeNames.Boolean)
-  def BooleanClass(implicit ctx: Context) = BooleanType.symbol.asClass
-    lazy val Boolean_notR   = BooleanClass.requiredMethodRef(nme.UNARY_!)
-    def Boolean_! = Boolean_notR.symbol
-    lazy val Boolean_andR = BooleanClass.requiredMethodRef(nme.ZAND) // ### harmonize required... calls
-    def Boolean_&& = Boolean_andR.symbol
-    lazy val Boolean_orR  = BooleanClass.requiredMethodRef(nme.ZOR)
-    def Boolean_|| = Boolean_orR.symbol
-    lazy val Boolean_eqeqR = BooleanClass.info.member(nme.EQ).suchThat(_.info.firstParamTypes match {
+  def UnitClass(implicit ctx: Context): ClassSymbol = UnitType.symbol.asClass
+  def UnitModuleClass(implicit ctx: Context): Symbol = UnitType.symbol.asClass.linkedClass
+  lazy val BooleanType: TypeRef = valueTypeRef("scala.Boolean", BoxedBooleanType, java.lang.Boolean.TYPE, BooleanEnc, nme.specializedTypeNames.Boolean)
+  def BooleanClass(implicit ctx: Context): ClassSymbol = BooleanType.symbol.asClass
+    lazy val Boolean_notR: TermRef   = BooleanClass.requiredMethodRef(nme.UNARY_!)
+    def Boolean_! : Symbol = Boolean_notR.symbol
+    lazy val Boolean_andR: TermRef = BooleanClass.requiredMethodRef(nme.ZAND) // ### harmonize required... calls
+    def Boolean_&& : Symbol = Boolean_andR.symbol
+    lazy val Boolean_orR: TermRef  = BooleanClass.requiredMethodRef(nme.ZOR)
+    def Boolean_|| : Symbol = Boolean_orR.symbol
+    lazy val Boolean_eqeqR: SingleDenotation = BooleanClass.info.member(nme.EQ).suchThat(_.info.firstParamTypes match {
       case List(pt) => (pt isRef BooleanClass)
       case _ => false
     })
-    def Boolean_== = Boolean_eqeqR.symbol
-    lazy val Boolean_neqeqR = BooleanClass.info.member(nme.NE).suchThat(_.info.firstParamTypes match {
+    def Boolean_== : Symbol = Boolean_eqeqR.symbol
+    lazy val Boolean_neqeqR: SingleDenotation = BooleanClass.info.member(nme.NE).suchThat(_.info.firstParamTypes match {
       case List(pt) => (pt isRef BooleanClass)
       case _ => false
     })
-    def Boolean_!= = Boolean_neqeqR.symbol
+    def Boolean_!= : Symbol = Boolean_neqeqR.symbol
 
   lazy val ByteType: TypeRef = valueTypeRef("scala.Byte", BoxedByteType, java.lang.Byte.TYPE, ByteEnc, nme.specializedTypeNames.Byte)
-  def ByteClass(implicit ctx: Context) = ByteType.symbol.asClass
+  def ByteClass(implicit ctx: Context): ClassSymbol = ByteType.symbol.asClass
   lazy val ShortType: TypeRef = valueTypeRef("scala.Short", BoxedShortType, java.lang.Short.TYPE, ShortEnc, nme.specializedTypeNames.Short)
-  def ShortClass(implicit ctx: Context) = ShortType.symbol.asClass
+  def ShortClass(implicit ctx: Context): ClassSymbol = ShortType.symbol.asClass
   lazy val CharType: TypeRef = valueTypeRef("scala.Char", BoxedCharType, java.lang.Character.TYPE, CharEnc, nme.specializedTypeNames.Char)
-  def CharClass(implicit ctx: Context) = CharType.symbol.asClass
+  def CharClass(implicit ctx: Context): ClassSymbol = CharType.symbol.asClass
   lazy val IntType: TypeRef = valueTypeRef("scala.Int", BoxedIntType, java.lang.Integer.TYPE, IntEnc, nme.specializedTypeNames.Int)
-  def IntClass(implicit ctx: Context) = IntType.symbol.asClass
-    lazy val Int_minusR   = IntClass.requiredMethodRef(nme.MINUS, List(IntType))
-    def Int_- = Int_minusR.symbol
-    lazy val Int_plusR   = IntClass.requiredMethodRef(nme.PLUS, List(IntType))
-    def Int_+ = Int_plusR.symbol
-    lazy val Int_divR   = IntClass.requiredMethodRef(nme.DIV, List(IntType))
-    def Int_/ = Int_divR.symbol
-    lazy val Int_mulR   = IntClass.requiredMethodRef(nme.MUL, List(IntType))
-    def Int_* = Int_mulR.symbol
-    lazy val Int_eqR   = IntClass.requiredMethodRef(nme.EQ, List(IntType))
-    def Int_== = Int_eqR.symbol
-    lazy val Int_geR   = IntClass.requiredMethodRef(nme.GE, List(IntType))
-    def Int_>= = Int_geR.symbol
-    lazy val Int_leR   = IntClass.requiredMethodRef(nme.LE, List(IntType))
-    def Int_<= = Int_leR.symbol
+  def IntClass(implicit ctx: Context): ClassSymbol = IntType.symbol.asClass
+    lazy val Int_minusR: TermRef   = IntClass.requiredMethodRef(nme.MINUS, List(IntType))
+    def Int_- : Symbol = Int_minusR.symbol
+    lazy val Int_plusR: TermRef   = IntClass.requiredMethodRef(nme.PLUS, List(IntType))
+    def Int_+ : Symbol = Int_plusR.symbol
+    lazy val Int_divR: TermRef   = IntClass.requiredMethodRef(nme.DIV, List(IntType))
+    def Int_/ : Symbol = Int_divR.symbol
+    lazy val Int_mulR: TermRef   = IntClass.requiredMethodRef(nme.MUL, List(IntType))
+    def Int_* : Symbol = Int_mulR.symbol
+    lazy val Int_eqR: TermRef   = IntClass.requiredMethodRef(nme.EQ, List(IntType))
+    def Int_== : Symbol = Int_eqR.symbol
+    lazy val Int_geR: TermRef   = IntClass.requiredMethodRef(nme.GE, List(IntType))
+    def Int_>= : Symbol = Int_geR.symbol
+    lazy val Int_leR: TermRef   = IntClass.requiredMethodRef(nme.LE, List(IntType))
+    def Int_<= : Symbol = Int_leR.symbol
   lazy val LongType: TypeRef = valueTypeRef("scala.Long", BoxedLongType, java.lang.Long.TYPE, LongEnc, nme.specializedTypeNames.Long)
-  def LongClass(implicit ctx: Context) = LongType.symbol.asClass
-    lazy val Long_XOR_Long = LongType.member(nme.XOR).requiredSymbol(
+  def LongClass(implicit ctx: Context): ClassSymbol = LongType.symbol.asClass
+    lazy val Long_XOR_Long: Symbol = LongType.member(nme.XOR).requiredSymbol(
       x => (x is Method) && (x.info.firstParamTypes.head isRef defn.LongClass)
     )
-    lazy val Long_LSR_Int = LongType.member(nme.LSR).requiredSymbol(
+    lazy val Long_LSR_Int: Symbol = LongType.member(nme.LSR).requiredSymbol(
       x => (x is Method) && (x.info.firstParamTypes.head isRef defn.IntClass)
     )
-    lazy val Long_plusR   = LongClass.requiredMethodRef(nme.PLUS, List(LongType))
-    def Long_+ = Long_plusR.symbol
-    lazy val Long_mulR   = LongClass.requiredMethodRef(nme.MUL, List(LongType))
-    def Long_* = Long_mulR.symbol
-    lazy val Long_divR   = LongClass.requiredMethodRef(nme.DIV, List(LongType))
-    def Long_/ = Long_divR.symbol
+    lazy val Long_plusR: TermRef   = LongClass.requiredMethodRef(nme.PLUS, List(LongType))
+    def Long_+ : Symbol = Long_plusR.symbol
+    lazy val Long_mulR: TermRef   = LongClass.requiredMethodRef(nme.MUL, List(LongType))
+    def Long_* : Symbol = Long_mulR.symbol
+    lazy val Long_divR: TermRef   = LongClass.requiredMethodRef(nme.DIV, List(LongType))
+    def Long_/ : Symbol = Long_divR.symbol
 
   lazy val FloatType: TypeRef = valueTypeRef("scala.Float", BoxedFloatType, java.lang.Float.TYPE, FloatEnc, nme.specializedTypeNames.Float)
-  def FloatClass(implicit ctx: Context) = FloatType.symbol.asClass
+  def FloatClass(implicit ctx: Context): ClassSymbol = FloatType.symbol.asClass
   lazy val DoubleType: TypeRef = valueTypeRef("scala.Double", BoxedDoubleType, java.lang.Double.TYPE, DoubleEnc, nme.specializedTypeNames.Double)
-  def DoubleClass(implicit ctx: Context) = DoubleType.symbol.asClass
+  def DoubleClass(implicit ctx: Context): ClassSymbol = DoubleType.symbol.asClass
 
   lazy val BoxedUnitType: TypeRef = ctx.requiredClassRef("scala.runtime.BoxedUnit")
-  def BoxedUnitClass(implicit ctx: Context) = BoxedUnitType.symbol.asClass
+  def BoxedUnitClass(implicit ctx: Context): ClassSymbol = BoxedUnitType.symbol.asClass
 
-    def BoxedUnit_UNIT(implicit ctx: Context) = BoxedUnitClass.linkedClass.requiredValue("UNIT")
+    def BoxedUnit_UNIT(implicit ctx: Context): TermSymbol = BoxedUnitClass.linkedClass.requiredValue("UNIT")
 
   lazy val BoxedBooleanType: TypeRef = ctx.requiredClassRef("java.lang.Boolean")
-  def BoxedBooleanClass(implicit ctx: Context) = BoxedBooleanType.symbol.asClass
+  def BoxedBooleanClass(implicit ctx: Context): ClassSymbol = BoxedBooleanType.symbol.asClass
   lazy val BoxedByteType: TypeRef = ctx.requiredClassRef("java.lang.Byte")
-  def BoxedByteClass(implicit ctx: Context) = BoxedByteType.symbol.asClass
+  def BoxedByteClass(implicit ctx: Context): ClassSymbol = BoxedByteType.symbol.asClass
   lazy val BoxedShortType: TypeRef = ctx.requiredClassRef("java.lang.Short")
-  def BoxedShortClass(implicit ctx: Context) = BoxedShortType.symbol.asClass
+  def BoxedShortClass(implicit ctx: Context): ClassSymbol = BoxedShortType.symbol.asClass
   lazy val BoxedCharType: TypeRef = ctx.requiredClassRef("java.lang.Character")
-  def BoxedCharClass(implicit ctx: Context) = BoxedCharType.symbol.asClass
+  def BoxedCharClass(implicit ctx: Context): ClassSymbol = BoxedCharType.symbol.asClass
   lazy val BoxedIntType: TypeRef = ctx.requiredClassRef("java.lang.Integer")
-  def BoxedIntClass(implicit ctx: Context) = BoxedIntType.symbol.asClass
+  def BoxedIntClass(implicit ctx: Context): ClassSymbol = BoxedIntType.symbol.asClass
   lazy val BoxedLongType: TypeRef = ctx.requiredClassRef("java.lang.Long")
-  def BoxedLongClass(implicit ctx: Context) = BoxedLongType.symbol.asClass
+  def BoxedLongClass(implicit ctx: Context): ClassSymbol = BoxedLongType.symbol.asClass
   lazy val BoxedFloatType: TypeRef = ctx.requiredClassRef("java.lang.Float")
-  def BoxedFloatClass(implicit ctx: Context) = BoxedFloatType.symbol.asClass
+  def BoxedFloatClass(implicit ctx: Context): ClassSymbol = BoxedFloatType.symbol.asClass
   lazy val BoxedDoubleType: TypeRef = ctx.requiredClassRef("java.lang.Double")
-  def BoxedDoubleClass(implicit ctx: Context) = BoxedDoubleType.symbol.asClass
+  def BoxedDoubleClass(implicit ctx: Context): ClassSymbol = BoxedDoubleType.symbol.asClass
 
-  lazy val BoxedBooleanModule = ctx.requiredModule("java.lang.Boolean")
-  lazy val BoxedByteModule    = ctx.requiredModule("java.lang.Byte")
-  lazy val BoxedShortModule   = ctx.requiredModule("java.lang.Short")
-  lazy val BoxedCharModule    = ctx.requiredModule("java.lang.Character")
-  lazy val BoxedIntModule     = ctx.requiredModule("java.lang.Integer")
-  lazy val BoxedLongModule    = ctx.requiredModule("java.lang.Long")
-  lazy val BoxedFloatModule   = ctx.requiredModule("java.lang.Float")
-  lazy val BoxedDoubleModule  = ctx.requiredModule("java.lang.Double")
-  lazy val BoxedUnitModule    = ctx.requiredModule("java.lang.Void")
+  lazy val BoxedBooleanModule: TermSymbol = ctx.requiredModule("java.lang.Boolean")
+  lazy val BoxedByteModule: TermSymbol    = ctx.requiredModule("java.lang.Byte")
+  lazy val BoxedShortModule: TermSymbol   = ctx.requiredModule("java.lang.Short")
+  lazy val BoxedCharModule: TermSymbol    = ctx.requiredModule("java.lang.Character")
+  lazy val BoxedIntModule: TermSymbol     = ctx.requiredModule("java.lang.Integer")
+  lazy val BoxedLongModule: TermSymbol    = ctx.requiredModule("java.lang.Long")
+  lazy val BoxedFloatModule: TermSymbol   = ctx.requiredModule("java.lang.Float")
+  lazy val BoxedDoubleModule: TermSymbol  = ctx.requiredModule("java.lang.Double")
+  lazy val BoxedUnitModule: TermSymbol    = ctx.requiredModule("java.lang.Void")
 
-  lazy val ByNameParamClass2x = enterSpecialPolyClass(tpnme.BYNAME_PARAM_CLASS, Covariant, Seq(AnyType))
-  lazy val EqualsPatternClass = enterSpecialPolyClass(tpnme.EQUALS_PATTERN, EmptyFlags, Seq(AnyType))
+  lazy val ByNameParamClass2x: ClassSymbol = enterSpecialPolyClass(tpnme.BYNAME_PARAM_CLASS, Covariant, Seq(AnyType))
+  lazy val EqualsPatternClass: ClassSymbol = enterSpecialPolyClass(tpnme.EQUALS_PATTERN, EmptyFlags, Seq(AnyType))
 
-  lazy val RepeatedParamClass = enterSpecialPolyClass(tpnme.REPEATED_PARAM_CLASS, Covariant, Seq(ObjectType, SeqType))
+  lazy val RepeatedParamClass: ClassSymbol = enterSpecialPolyClass(tpnme.REPEATED_PARAM_CLASS, Covariant, Seq(ObjectType, SeqType))
 
   // fundamental classes
-  lazy val StringClass                = ctx.requiredClass("java.lang.String")
+  lazy val StringClass: ClassSymbol                = ctx.requiredClass("java.lang.String")
   def StringType: Type                = StringClass.typeRef
-  lazy val StringModule               = StringClass.linkedClass
+  lazy val StringModule: Symbol               = StringClass.linkedClass
 
-    lazy val String_+ = enterMethod(StringClass, nme.raw.PLUS, methOfAny(StringType), Final)
-    lazy val String_valueOf_Object = StringModule.info.member(nme.valueOf).suchThat(_.info.firstParamTypes match {
+    lazy val String_+ : TermSymbol = enterMethod(StringClass, nme.raw.PLUS, methOfAny(StringType), Final)
+    lazy val String_valueOf_Object: Symbol = StringModule.info.member(nme.valueOf).suchThat(_.info.firstParamTypes match {
       case List(pt) => (pt isRef AnyClass) || (pt isRef ObjectClass)
       case _ => false
     }).symbol
 
-  lazy val JavaCloneableClass        = ctx.requiredClass("java.lang.Cloneable")
-  lazy val NullPointerExceptionClass = ctx.requiredClass("java.lang.NullPointerException")
-  lazy val IndexOutOfBoundsException = ctx.requiredClass("java.lang.IndexOutOfBoundsException")
-  lazy val ClassClass                = ctx.requiredClass("java.lang.Class")
-  lazy val BoxedNumberClass          = ctx.requiredClass("java.lang.Number")
-  lazy val ClassCastExceptionClass   = ctx.requiredClass("java.lang.ClassCastException")
-  lazy val ArithmeticExceptionClass  = ctx.requiredClass("java.lang.ArithmeticException")
-    lazy val ArithmeticExceptionClass_stringConstructor  = ArithmeticExceptionClass.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match {
+  lazy val JavaCloneableClass: ClassSymbol        = ctx.requiredClass("java.lang.Cloneable")
+  lazy val NullPointerExceptionClass: ClassSymbol = ctx.requiredClass("java.lang.NullPointerException")
+  lazy val IndexOutOfBoundsException: ClassSymbol = ctx.requiredClass("java.lang.IndexOutOfBoundsException")
+  lazy val ClassClass: ClassSymbol                = ctx.requiredClass("java.lang.Class")
+  lazy val BoxedNumberClass: ClassSymbol          = ctx.requiredClass("java.lang.Number")
+  lazy val ClassCastExceptionClass: ClassSymbol   = ctx.requiredClass("java.lang.ClassCastException")
+  lazy val ArithmeticExceptionClass: ClassSymbol  = ctx.requiredClass("java.lang.ArithmeticException")
+    lazy val ArithmeticExceptionClass_stringConstructor: TermSymbol  = ArithmeticExceptionClass.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match {
       case List(pt) => (pt isRef StringClass)
       case _ => false
     }).symbol.asTerm
-  lazy val JavaSerializableClass     = ctx.requiredClass("java.io.Serializable")
-  lazy val ComparableClass           = ctx.requiredClass("java.lang.Comparable")
+  lazy val JavaSerializableClass: ClassSymbol     = ctx.requiredClass("java.io.Serializable")
+  lazy val ComparableClass: ClassSymbol           = ctx.requiredClass("java.lang.Comparable")
 
-  lazy val SystemClass               = ctx.requiredClass("java.lang.System")
-  lazy val SystemModule              = SystemClass.linkedClass
+  lazy val SystemClass: ClassSymbol               = ctx.requiredClass("java.lang.System")
+  lazy val SystemModule: Symbol              = SystemClass.linkedClass
 
   // in scalac modified to have Any as parent
 
   lazy val ThrowableType: TypeRef          = ctx.requiredClassRef("java.lang.Throwable")
-  def ThrowableClass(implicit ctx: Context) = ThrowableType.symbol.asClass
+  def ThrowableClass(implicit ctx: Context): ClassSymbol = ThrowableType.symbol.asClass
   lazy val SerializableType: TypeRef       = ctx.requiredClassRef("scala.Serializable")
-  def SerializableClass(implicit ctx: Context) = SerializableType.symbol.asClass
+  def SerializableClass(implicit ctx: Context): ClassSymbol = SerializableType.symbol.asClass
   lazy val StringBuilderType: TypeRef      = ctx.requiredClassRef("scala.collection.mutable.StringBuilder")
-  def StringBuilderClass(implicit ctx: Context) = StringBuilderType.symbol.asClass
+  def StringBuilderClass(implicit ctx: Context): ClassSymbol = StringBuilderType.symbol.asClass
   lazy val MatchErrorType: TypeRef         = ctx.requiredClassRef("scala.MatchError")
-  def MatchErrorClass(implicit ctx: Context) = MatchErrorType.symbol.asClass
+  def MatchErrorClass(implicit ctx: Context): ClassSymbol = MatchErrorType.symbol.asClass
 
   lazy val StringAddType: TypeRef          = ctx.requiredClassRef("scala.runtime.StringAdd")
-  def StringAddClass(implicit ctx: Context) = StringAddType.symbol.asClass
+  def StringAddClass(implicit ctx: Context): ClassSymbol = StringAddType.symbol.asClass
 
-    lazy val StringAdd_plusR = StringAddClass.requiredMethodRef(nme.raw.PLUS)
-    def StringAdd_+(implicit ctx: Context) = StringAdd_plusR.symbol
+    lazy val StringAdd_plusR: TermRef = StringAddClass.requiredMethodRef(nme.raw.PLUS)
+    def StringAdd_+(implicit ctx: Context): Symbol = StringAdd_plusR.symbol
 
   lazy val StringContextType: TypeRef       = ctx.requiredClassRef("scala.StringContext")
-  def StringContextClass(implicit ctx: Context) = StringContextType.symbol.asClass
-    lazy val StringContextSR = StringContextClass.requiredMethodRef(nme.s)
-    def StringContextS(implicit ctx: Context) = StringContextSR.symbol
-    lazy val StringContextRawR = StringContextClass.requiredMethodRef(nme.raw_)
-    def StringContextRaw(implicit ctx: Context) = StringContextRawR.symbol
-  def StringContextModule(implicit ctx: Context) = StringContextClass.companionModule
-    lazy val StringContextModule_applyR = StringContextModule.requiredMethodRef(nme.apply)
-    def StringContextModule_apply(implicit ctx: Context) = StringContextModule_applyR.symbol
+  def StringContextClass(implicit ctx: Context): ClassSymbol = StringContextType.symbol.asClass
+    lazy val StringContextSR: TermRef = StringContextClass.requiredMethodRef(nme.s)
+    def StringContextS(implicit ctx: Context): Symbol = StringContextSR.symbol
+    lazy val StringContextRawR: TermRef = StringContextClass.requiredMethodRef(nme.raw_)
+    def StringContextRaw(implicit ctx: Context): Symbol = StringContextRawR.symbol
+  def StringContextModule(implicit ctx: Context): Symbol = StringContextClass.companionModule
+    lazy val StringContextModule_applyR: TermRef = StringContextModule.requiredMethodRef(nme.apply)
+    def StringContextModule_apply(implicit ctx: Context): Symbol = StringContextModule_applyR.symbol
 
   lazy val PartialFunctionType: TypeRef         = ctx.requiredClassRef("scala.PartialFunction")
-  def PartialFunctionClass(implicit ctx: Context) = PartialFunctionType.symbol.asClass
-    lazy val PartialFunction_isDefinedAtR = PartialFunctionClass.requiredMethodRef(nme.isDefinedAt)
-    def PartialFunction_isDefinedAt(implicit ctx: Context) = PartialFunction_isDefinedAtR.symbol
-    lazy val PartialFunction_applyOrElseR = PartialFunctionClass.requiredMethodRef(nme.applyOrElse)
-    def PartialFunction_applyOrElse(implicit ctx: Context) = PartialFunction_applyOrElseR.symbol
+  def PartialFunctionClass(implicit ctx: Context): ClassSymbol = PartialFunctionType.symbol.asClass
+    lazy val PartialFunction_isDefinedAtR: TermRef = PartialFunctionClass.requiredMethodRef(nme.isDefinedAt)
+    def PartialFunction_isDefinedAt(implicit ctx: Context): Symbol = PartialFunction_isDefinedAtR.symbol
+    lazy val PartialFunction_applyOrElseR: TermRef = PartialFunctionClass.requiredMethodRef(nme.applyOrElse)
+    def PartialFunction_applyOrElse(implicit ctx: Context): Symbol = PartialFunction_applyOrElseR.symbol
 
   lazy val AbstractPartialFunctionType: TypeRef = ctx.requiredClassRef("scala.runtime.AbstractPartialFunction")
-  def AbstractPartialFunctionClass(implicit ctx: Context) = AbstractPartialFunctionType.symbol.asClass
+  def AbstractPartialFunctionClass(implicit ctx: Context): ClassSymbol = AbstractPartialFunctionType.symbol.asClass
 
   lazy val FunctionXXLType: TypeRef         = ctx.requiredClassRef("scala.FunctionXXL")
-  def FunctionXXLClass(implicit ctx: Context) = FunctionXXLType.symbol.asClass
+  def FunctionXXLClass(implicit ctx: Context): ClassSymbol = FunctionXXLType.symbol.asClass
 
   lazy val ScalaSymbolType: TypeRef                    = ctx.requiredClassRef("scala.Symbol")
-  def ScalaSymbolClass(implicit ctx: Context)          = ScalaSymbolType.symbol.asClass
-  def ScalaSymbolModule(implicit ctx: Context)         = ScalaSymbolClass.companionModule
-    lazy val ScalaSymbolModule_applyR                  = ScalaSymbolModule.requiredMethodRef(nme.apply, List(StringType))
-    def ScalaSymbolModule_apply(implicit ctx: Context) = ScalaSymbolModule_applyR.symbol
+  def ScalaSymbolClass(implicit ctx: Context): ClassSymbol          = ScalaSymbolType.symbol.asClass
+  def ScalaSymbolModule(implicit ctx: Context): Symbol         = ScalaSymbolClass.companionModule
+    lazy val ScalaSymbolModule_applyR: TermRef                  = ScalaSymbolModule.requiredMethodRef(nme.apply, List(StringType))
+    def ScalaSymbolModule_apply(implicit ctx: Context): Symbol = ScalaSymbolModule_applyR.symbol
 
   lazy val DynamicType: TypeRef                 = ctx.requiredClassRef("scala.Dynamic")
-  def DynamicClass(implicit ctx: Context) = DynamicType.symbol.asClass
+  def DynamicClass(implicit ctx: Context): ClassSymbol = DynamicType.symbol.asClass
   lazy val OptionType: TypeRef                  = ctx.requiredClassRef("scala.Option")
-  def OptionClass(implicit ctx: Context) = OptionType.symbol.asClass
+  def OptionClass(implicit ctx: Context): ClassSymbol = OptionType.symbol.asClass
   lazy val SomeType: TypeRef                  = ctx.requiredClassRef("scala.Some")
-  def SomeClass(implicit ctx: Context) = SomeType.symbol.asClass
+  def SomeClass(implicit ctx: Context): ClassSymbol = SomeType.symbol.asClass
   lazy val NoneModuleRef: TermRef                  = ctx.requiredModuleRef("scala.None")
-  def NoneClass(implicit ctx: Context) = NoneModuleRef.symbol.moduleClass.asClass
+  def NoneClass(implicit ctx: Context): ClassSymbol = NoneModuleRef.symbol.moduleClass.asClass
   lazy val EnumType: TypeRef                    = ctx.requiredClassRef("scala.Enum")
-  def EnumClass(implicit ctx: Context) = EnumType.symbol.asClass
+  def EnumClass(implicit ctx: Context): ClassSymbol = EnumType.symbol.asClass
   lazy val EnumValuesType: TypeRef              = ctx.requiredClassRef("scala.runtime.EnumValues")
-  def EnumValuesClass(implicit ctx: Context) = EnumValuesType.symbol.asClass
+  def EnumValuesClass(implicit ctx: Context): ClassSymbol = EnumValuesType.symbol.asClass
   lazy val ProductType: TypeRef                 = ctx.requiredClassRef("scala.Product")
-  def ProductClass(implicit ctx: Context) = ProductType.symbol.asClass
-    lazy val Product_canEqualR = ProductClass.requiredMethodRef(nme.canEqual_)
-    def Product_canEqual(implicit ctx: Context) = Product_canEqualR.symbol
-    lazy val Product_productArityR = ProductClass.requiredMethodRef(nme.productArity)
-    def Product_productArity(implicit ctx: Context) = Product_productArityR.symbol
-    lazy val Product_productElementR = ProductClass.requiredMethodRef(nme.productElement)
-    def Product_productElement(implicit ctx: Context) = Product_productElementR.symbol
-    lazy val Product_productPrefixR = ProductClass.requiredMethodRef(nme.productPrefix)
-    def Product_productPrefix(implicit ctx: Context) = Product_productPrefixR.symbol
-  lazy val LanguageModuleRef = ctx.requiredModule("scala.language")
-  def LanguageModuleClass(implicit ctx: Context) = LanguageModuleRef.moduleClass.asClass
+  def ProductClass(implicit ctx: Context): ClassSymbol = ProductType.symbol.asClass
+    lazy val Product_canEqualR: TermRef = ProductClass.requiredMethodRef(nme.canEqual_)
+    def Product_canEqual(implicit ctx: Context): Symbol = Product_canEqualR.symbol
+    lazy val Product_productArityR: TermRef = ProductClass.requiredMethodRef(nme.productArity)
+    def Product_productArity(implicit ctx: Context): Symbol = Product_productArityR.symbol
+    lazy val Product_productElementR: TermRef = ProductClass.requiredMethodRef(nme.productElement)
+    def Product_productElement(implicit ctx: Context): Symbol = Product_productElementR.symbol
+    lazy val Product_productPrefixR: TermRef = ProductClass.requiredMethodRef(nme.productPrefix)
+    def Product_productPrefix(implicit ctx: Context): Symbol = Product_productPrefixR.symbol
+  lazy val LanguageModuleRef: TermSymbol = ctx.requiredModule("scala.language")
+  def LanguageModuleClass(implicit ctx: Context): ClassSymbol = LanguageModuleRef.moduleClass.asClass
   lazy val NonLocalReturnControlType: TypeRef   = ctx.requiredClassRef("scala.runtime.NonLocalReturnControl")
   lazy val SelectableType: TypeRef              = ctx.requiredClassRef("scala.Selectable")
 
-  lazy val ClassTagType = ctx.requiredClassRef("scala.reflect.ClassTag")
-  def ClassTagClass(implicit ctx: Context) = ClassTagType.symbol.asClass
-  def ClassTagModule(implicit ctx: Context) = ClassTagClass.companionModule
+  lazy val ClassTagType: TypeRef = ctx.requiredClassRef("scala.reflect.ClassTag")
+  def ClassTagClass(implicit ctx: Context): ClassSymbol = ClassTagType.symbol.asClass
+  def ClassTagModule(implicit ctx: Context): Symbol = ClassTagClass.companionModule
 
-  lazy val QuotedExprType = ctx.requiredClassRef("scala.quoted.Expr")
-  def QuotedExprClass(implicit ctx: Context) = QuotedExprType.symbol.asClass
-  def QuotedExprModule(implicit ctx: Context) = QuotedExprClass.companionModule
-    lazy val QuotedExpr_applyR = QuotedExprModule.requiredMethodRef(nme.apply)
-    def QuotedExpr_apply(implicit ctx: Context) = QuotedExpr_applyR.symbol
-    lazy val QuotedExpr_~ = QuotedExprClass.requiredMethod(nme.UNARY_~)
+  lazy val QuotedExprType: TypeRef = ctx.requiredClassRef("scala.quoted.Expr")
+  def QuotedExprClass(implicit ctx: Context): ClassSymbol = QuotedExprType.symbol.asClass
+  def QuotedExprModule(implicit ctx: Context): Symbol = QuotedExprClass.companionModule
+    lazy val QuotedExpr_applyR: TermRef = QuotedExprModule.requiredMethodRef(nme.apply)
+    def QuotedExpr_apply(implicit ctx: Context): Symbol = QuotedExpr_applyR.symbol
+    lazy val QuotedExpr_~ : TermSymbol = QuotedExprClass.requiredMethod(nme.UNARY_~)
 
-  lazy val QuotedExprsModule = ctx.requiredModule("scala.quoted.Exprs")
-  def QuotedExprsClass(implicit ctx: Context) = QuotedExprsModule.asClass
+  lazy val QuotedExprsModule: TermSymbol = ctx.requiredModule("scala.quoted.Exprs")
+  def QuotedExprsClass(implicit ctx: Context): ClassSymbol = QuotedExprsModule.asClass
 
-  lazy val QuotedTypeType = ctx.requiredClassRef("scala.quoted.Type")
-  def QuotedTypeClass(implicit ctx: Context) = QuotedTypeType.symbol.asClass
+  lazy val QuotedTypeType: TypeRef = ctx.requiredClassRef("scala.quoted.Type")
+  def QuotedTypeClass(implicit ctx: Context): ClassSymbol = QuotedTypeType.symbol.asClass
 
-    lazy val QuotedType_spliceR = QuotedTypeClass.requiredType(tpnme.UNARY_~).typeRef
-    def QuotedType_~ = QuotedType_spliceR.symbol
+    lazy val QuotedType_spliceR: TypeRef = QuotedTypeClass.requiredType(tpnme.UNARY_~).typeRef
+    def QuotedType_~ : Symbol = QuotedType_spliceR.symbol
 
-  lazy val QuotedTypeModuleType = ctx.requiredModuleRef("scala.quoted.Type")
-  def QuotedTypeModule(implicit ctx: Context) = QuotedTypeModuleType.symbol
-    lazy val QuotedType_applyR = QuotedTypeModule.requiredMethodRef(nme.apply)
-    def QuotedType_apply(implicit ctx: Context) = QuotedType_applyR.symbol
+  lazy val QuotedTypeModuleType: TermRef = ctx.requiredModuleRef("scala.quoted.Type")
+  def QuotedTypeModule(implicit ctx: Context): Symbol = QuotedTypeModuleType.symbol
+    lazy val QuotedType_applyR: TermRef = QuotedTypeModule.requiredMethodRef(nme.apply)
+    def QuotedType_apply(implicit ctx: Context): Symbol = QuotedType_applyR.symbol
 
-  lazy val QuotedLiftableModule = ctx.requiredModule("scala.quoted.Liftable")
-  def QuotedLiftableModuleClass(implicit ctx: Context) = QuotedLiftableModule.asClass
+  lazy val QuotedLiftableModule: TermSymbol = ctx.requiredModule("scala.quoted.Liftable")
+  def QuotedLiftableModuleClass(implicit ctx: Context): ClassSymbol = QuotedLiftableModule.asClass
 
-    def QuotedLiftable_BooleanIsLiftable = QuotedLiftableModule.requiredMethodRef("BooleanIsLiftable")
-    def QuotedLiftable_ByteIsLiftable = QuotedLiftableModule.requiredMethodRef("ByteIsLiftable")
-    def QuotedLiftable_CharIsLiftable = QuotedLiftableModule.requiredMethodRef("CharIsLiftable")
-    def QuotedLiftable_ShortIsLiftable = QuotedLiftableModule.requiredMethodRef("ShortIsLiftable")
-    def QuotedLiftable_IntIsLiftable = QuotedLiftableModule.requiredMethodRef("IntIsLiftable")
-    def QuotedLiftable_LongIsLiftable = QuotedLiftableModule.requiredMethodRef("LongIsLiftable")
-    def QuotedLiftable_FloatIsLiftable = QuotedLiftableModule.requiredMethodRef("FloatIsLiftable")
-    def QuotedLiftable_DoubleIsLiftable = QuotedLiftableModule.requiredMethodRef("DoubleIsLiftable")
-    def QuotedLiftable_StringIsLiftable = QuotedLiftableModule.requiredMethodRef("StringIsLiftable")
+    def QuotedLiftable_BooleanIsLiftable: TermRef = QuotedLiftableModule.requiredMethodRef("BooleanIsLiftable")
+    def QuotedLiftable_ByteIsLiftable: TermRef = QuotedLiftableModule.requiredMethodRef("ByteIsLiftable")
+    def QuotedLiftable_CharIsLiftable: TermRef = QuotedLiftableModule.requiredMethodRef("CharIsLiftable")
+    def QuotedLiftable_ShortIsLiftable: TermRef = QuotedLiftableModule.requiredMethodRef("ShortIsLiftable")
+    def QuotedLiftable_IntIsLiftable: TermRef = QuotedLiftableModule.requiredMethodRef("IntIsLiftable")
+    def QuotedLiftable_LongIsLiftable: TermRef = QuotedLiftableModule.requiredMethodRef("LongIsLiftable")
+    def QuotedLiftable_FloatIsLiftable: TermRef = QuotedLiftableModule.requiredMethodRef("FloatIsLiftable")
+    def QuotedLiftable_DoubleIsLiftable: TermRef = QuotedLiftableModule.requiredMethodRef("DoubleIsLiftable")
+    def QuotedLiftable_StringIsLiftable: TermRef = QuotedLiftableModule.requiredMethodRef("StringIsLiftable")
 
-  lazy val QuotedLiftableType = ctx.requiredClassRef("scala.quoted.Liftable")
-  def QuotedLiftableClass(implicit ctx: Context) = QuotedLiftableType.symbol.asClass
+  lazy val QuotedLiftableType: TypeRef = ctx.requiredClassRef("scala.quoted.Liftable")
+  def QuotedLiftableClass(implicit ctx: Context): ClassSymbol = QuotedLiftableType.symbol.asClass
 
-  def Unpickler_unpickleExpr = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleExpr")
-  def Unpickler_liftedExpr = ctx.requiredMethod("scala.runtime.quoted.Unpickler.liftedExpr")
-  def Unpickler_unpickleType = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleType")
+  def Unpickler_unpickleExpr: TermSymbol = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleExpr")
+  def Unpickler_liftedExpr: TermSymbol = ctx.requiredMethod("scala.runtime.quoted.Unpickler.liftedExpr")
+  def Unpickler_unpickleType: TermSymbol = ctx.requiredMethod("scala.runtime.quoted.Unpickler.unpickleType")
 
-  lazy val TastyTastyType = ctx.requiredClassRef("scala.tasty.Tasty")
-  def TastyTastyClass(implicit ctx: Context) = TastyTastyType.symbol.asClass
+  lazy val TastyTastyType: TypeRef = ctx.requiredClassRef("scala.tasty.Tasty")
+  def TastyTastyClass(implicit ctx: Context): ClassSymbol = TastyTastyType.symbol.asClass
 
-  lazy val TastyTastyModule = ctx.requiredModule("scala.tasty.Tasty")
-    lazy val TastyTasty_macroContext = TastyTastyModule.requiredMethod("macroContext")
+  lazy val TastyTastyModule: TermSymbol = ctx.requiredModule("scala.tasty.Tasty")
+    lazy val TastyTasty_macroContext: TermSymbol = TastyTastyModule.requiredMethod("macroContext")
 
-  lazy val EqType = ctx.requiredClassRef("scala.Eq")
-  def EqClass(implicit ctx: Context) = EqType.symbol.asClass
-  def EqModule(implicit ctx: Context) = EqClass.companionModule
+  lazy val EqType: TypeRef = ctx.requiredClassRef("scala.Eq")
+  def EqClass(implicit ctx: Context): ClassSymbol = EqType.symbol.asClass
+  def EqModule(implicit ctx: Context): Symbol = EqClass.companionModule
 
-    def Eq_eqAny(implicit ctx: Context) = EqModule.requiredMethod(nme.eqAny)
+    def Eq_eqAny(implicit ctx: Context): TermSymbol = EqModule.requiredMethod(nme.eqAny)
 
-  lazy val NotType = ctx.requiredClassRef("scala.implicits.Not")
-  def NotClass(implicit ctx: Context) = NotType.symbol.asClass
-  def NotModule(implicit ctx: Context) = NotClass.companionModule
+  lazy val NotType: TypeRef = ctx.requiredClassRef("scala.implicits.Not")
+  def NotClass(implicit ctx: Context): ClassSymbol = NotType.symbol.asClass
+  def NotModule(implicit ctx: Context): Symbol = NotClass.companionModule
 
-    def Not_value(implicit ctx: Context) = NotModule.requiredMethod(nme.value)
+    def Not_value(implicit ctx: Context): TermSymbol = NotModule.requiredMethod(nme.value)
 
-  lazy val XMLTopScopeModuleRef = ctx.requiredModuleRef("scala.xml.TopScope")
+  lazy val XMLTopScopeModuleRef: TermRef = ctx.requiredModuleRef("scala.xml.TopScope")
 
-  lazy val TupleTypeRef = ctx.requiredClassRef("scala.Tuple")
-  def TupleClass(implicit ctx: Context) = TupleTypeRef.symbol.asClass
-  lazy val NonEmptyTupleTypeRef = ctx.requiredClassRef("scala.NonEmptyTuple")
-  def NonEmptyTupleClass(implicit ctx: Context) = NonEmptyTupleTypeRef.symbol.asClass
+  lazy val TupleTypeRef: TypeRef = ctx.requiredClassRef("scala.Tuple")
+  def TupleClass(implicit ctx: Context): ClassSymbol = TupleTypeRef.symbol.asClass
+  lazy val NonEmptyTupleTypeRef: TypeRef = ctx.requiredClassRef("scala.NonEmptyTuple")
+  def NonEmptyTupleClass(implicit ctx: Context): ClassSymbol = NonEmptyTupleTypeRef.symbol.asClass
 
-  lazy val PairType = ctx.requiredClassRef("scala.*:")
-  def PairClass(implicit ctx: Context) = PairType.symbol.asClass
-  lazy val TupleXXLType = ctx.requiredClassRef("scala.TupleXXL")
-  def TupleXXLClass(implicit ctx: Context) = TupleXXLType.symbol.asClass
-  def TupleXXLModule(implicit ctx: Context) = TupleXXLClass.companionModule
+  lazy val PairType: TypeRef = ctx.requiredClassRef("scala.*:")
+  def PairClass(implicit ctx: Context): ClassSymbol = PairType.symbol.asClass
+  lazy val TupleXXLType: TypeRef = ctx.requiredClassRef("scala.TupleXXL")
+  def TupleXXLClass(implicit ctx: Context): ClassSymbol = TupleXXLType.symbol.asClass
+  def TupleXXLModule(implicit ctx: Context): Symbol = TupleXXLClass.companionModule
 
-    def TupleXXL_apply(implicit ctx: Context) =
+    def TupleXXL_apply(implicit ctx: Context): Symbol =
       TupleXXLModule.info.member(nme.apply).requiredSymbol(_.info.isVarArgsMethod)
 
   // Annotation base classes
-  lazy val AnnotationType              = ctx.requiredClassRef("scala.annotation.Annotation")
-  def AnnotationClass(implicit ctx: Context) = AnnotationType.symbol.asClass
-  lazy val ClassfileAnnotationType     = ctx.requiredClassRef("scala.annotation.ClassfileAnnotation")
-  def ClassfileAnnotationClass(implicit ctx: Context) = ClassfileAnnotationType.symbol.asClass
-  lazy val StaticAnnotationType        = ctx.requiredClassRef("scala.annotation.StaticAnnotation")
-  def StaticAnnotationClass(implicit ctx: Context) = StaticAnnotationType.symbol.asClass
-  lazy val RefiningAnnotationType      = ctx.requiredClassRef("scala.annotation.RefiningAnnotation")
-  def RefiningAnnotationClass(implicit ctx: Context) = RefiningAnnotationType.symbol.asClass
+  lazy val AnnotationType: TypeRef              = ctx.requiredClassRef("scala.annotation.Annotation")
+  def AnnotationClass(implicit ctx: Context): ClassSymbol = AnnotationType.symbol.asClass
+  lazy val ClassfileAnnotationType: TypeRef     = ctx.requiredClassRef("scala.annotation.ClassfileAnnotation")
+  def ClassfileAnnotationClass(implicit ctx: Context): ClassSymbol = ClassfileAnnotationType.symbol.asClass
+  lazy val StaticAnnotationType: TypeRef        = ctx.requiredClassRef("scala.annotation.StaticAnnotation")
+  def StaticAnnotationClass(implicit ctx: Context): ClassSymbol = StaticAnnotationType.symbol.asClass
+  lazy val RefiningAnnotationType: TypeRef      = ctx.requiredClassRef("scala.annotation.RefiningAnnotation")
+  def RefiningAnnotationClass(implicit ctx: Context): ClassSymbol = RefiningAnnotationType.symbol.asClass
 
   // Annotation classes
-  lazy val AliasAnnotType = ctx.requiredClassRef("scala.annotation.internal.Alias")
-  def AliasAnnot(implicit ctx: Context) = AliasAnnotType.symbol.asClass
-  lazy val AnnotationDefaultAnnotType = ctx.requiredClassRef("scala.annotation.internal.AnnotationDefault")
-  def AnnotationDefaultAnnot(implicit ctx: Context) = AnnotationDefaultAnnotType.symbol.asClass
-  lazy val BodyAnnotType = ctx.requiredClassRef("scala.annotation.internal.Body")
-  def BodyAnnot(implicit ctx: Context) = BodyAnnotType.symbol.asClass
-  lazy val ChildAnnotType = ctx.requiredClassRef("scala.annotation.internal.Child")
-  def ChildAnnot(implicit ctx: Context) = ChildAnnotType.symbol.asClass
-  lazy val CovariantBetweenAnnotType = ctx.requiredClassRef("scala.annotation.internal.CovariantBetween")
-  def CovariantBetweenAnnot(implicit ctx: Context) = CovariantBetweenAnnotType.symbol.asClass
-  lazy val ContravariantBetweenAnnotType = ctx.requiredClassRef("scala.annotation.internal.ContravariantBetween")
-  def ContravariantBetweenAnnot(implicit ctx: Context) = ContravariantBetweenAnnotType.symbol.asClass
-  lazy val DeprecatedAnnotType = ctx.requiredClassRef("scala.deprecated")
-  def DeprecatedAnnot(implicit ctx: Context) = DeprecatedAnnotType.symbol.asClass
-  lazy val ImplicitAmbiguousAnnotType = ctx.requiredClassRef("scala.annotation.implicitAmbiguous")
-  def ImplicitAmbiguousAnnot(implicit ctx: Context) = ImplicitAmbiguousAnnotType.symbol.asClass
-  lazy val ImplicitNotFoundAnnotType = ctx.requiredClassRef("scala.annotation.implicitNotFound")
-  def ImplicitNotFoundAnnot(implicit ctx: Context) = ImplicitNotFoundAnnotType.symbol.asClass
-  lazy val ForceInlineAnnotType = ctx.requiredClassRef("scala.forceInline")
-  def ForceInlineAnnot(implicit ctx: Context) = ForceInlineAnnotType.symbol.asClass
-  lazy val InlineParamAnnotType = ctx.requiredClassRef("scala.annotation.internal.InlineParam")
-  def InlineParamAnnot(implicit ctx: Context) = InlineParamAnnotType.symbol.asClass
-  lazy val InvariantBetweenAnnotType = ctx.requiredClassRef("scala.annotation.internal.InvariantBetween")
-  def InvariantBetweenAnnot(implicit ctx: Context) = InvariantBetweenAnnotType.symbol.asClass
-  lazy val MigrationAnnotType = ctx.requiredClassRef("scala.annotation.migration")
-  def MigrationAnnot(implicit ctx: Context) = MigrationAnnotType.symbol.asClass
-  lazy val NativeAnnotType                   = ctx.requiredClassRef("scala.native")
-  def NativeAnnot(implicit ctx: Context) = NativeAnnotType.symbol.asClass
-  lazy val RepeatedAnnotType = ctx.requiredClassRef("scala.annotation.internal.Repeated")
-  def RepeatedAnnot(implicit ctx: Context) = RepeatedAnnotType.symbol.asClass
-  lazy val SourceFileAnnotType = ctx.requiredClassRef("scala.annotation.internal.SourceFile")
-  def SourceFileAnnot(implicit ctx: Context) = SourceFileAnnotType.symbol.asClass
-  lazy val ScalaSignatureAnnotType = ctx.requiredClassRef("scala.reflect.ScalaSignature")
-  def ScalaSignatureAnnot(implicit ctx: Context) = ScalaSignatureAnnotType.symbol.asClass
-  lazy val ScalaLongSignatureAnnotType = ctx.requiredClassRef("scala.reflect.ScalaLongSignature")
-  def ScalaLongSignatureAnnot(implicit ctx: Context) = ScalaLongSignatureAnnotType.symbol.asClass
-  lazy val ScalaStrictFPAnnotType            = ctx.requiredClassRef("scala.annotation.strictfp")
-  def ScalaStrictFPAnnot(implicit ctx: Context) = ScalaStrictFPAnnotType.symbol.asClass
-  lazy val ScalaStaticAnnotType            = ctx.requiredClassRef("scala.annotation.static")
-  def ScalaStaticAnnot(implicit ctx: Context) = ScalaStaticAnnotType.symbol.asClass
-  lazy val SerialVersionUIDAnnotType         = ctx.requiredClassRef("scala.SerialVersionUID")
-  def SerialVersionUIDAnnot(implicit ctx: Context) = SerialVersionUIDAnnotType.symbol.asClass
-  lazy val TASTYSignatureAnnotType = ctx.requiredClassRef("scala.annotation.internal.TASTYSignature")
-  def TASTYSignatureAnnot(implicit ctx: Context) = TASTYSignatureAnnotType.symbol.asClass
-  lazy val TASTYLongSignatureAnnotType = ctx.requiredClassRef("scala.annotation.internal.TASTYLongSignature")
-  def TASTYLongSignatureAnnot(implicit ctx: Context) = TASTYLongSignatureAnnotType.symbol.asClass
-  lazy val TailrecAnnotType = ctx.requiredClassRef("scala.annotation.tailrec")
-  def TailrecAnnot(implicit ctx: Context) = TailrecAnnotType.symbol.asClass
-  lazy val SwitchAnnotType = ctx.requiredClassRef("scala.annotation.switch")
-  def SwitchAnnot(implicit ctx: Context) = SwitchAnnotType.symbol.asClass
-  lazy val ThrowsAnnotType = ctx.requiredClassRef("scala.throws")
-  def ThrowsAnnot(implicit ctx: Context) = ThrowsAnnotType.symbol.asClass
-  lazy val TransientAnnotType                = ctx.requiredClassRef("scala.transient")
-  def TransientAnnot(implicit ctx: Context) = TransientAnnotType.symbol.asClass
-  lazy val UncheckedAnnotType = ctx.requiredClassRef("scala.unchecked")
-  def UncheckedAnnot(implicit ctx: Context) = UncheckedAnnotType.symbol.asClass
-  lazy val UncheckedStableAnnotType = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedStable")
-  def UncheckedStableAnnot(implicit ctx: Context) = UncheckedStableAnnotType.symbol.asClass
-  lazy val UncheckedVarianceAnnotType = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedVariance")
-  def UncheckedVarianceAnnot(implicit ctx: Context) = UncheckedVarianceAnnotType.symbol.asClass
-  lazy val VolatileAnnotType = ctx.requiredClassRef("scala.volatile")
-  def VolatileAnnot(implicit ctx: Context) = VolatileAnnotType.symbol.asClass
-  lazy val FieldMetaAnnotType = ctx.requiredClassRef("scala.annotation.meta.field")
-  def FieldMetaAnnot(implicit ctx: Context) = FieldMetaAnnotType.symbol.asClass
-  lazy val GetterMetaAnnotType = ctx.requiredClassRef("scala.annotation.meta.getter")
-  def GetterMetaAnnot(implicit ctx: Context) = GetterMetaAnnotType.symbol.asClass
-  lazy val SetterMetaAnnotType = ctx.requiredClassRef("scala.annotation.meta.setter")
-  def SetterMetaAnnot(implicit ctx: Context) = SetterMetaAnnotType.symbol.asClass
-  lazy val ShowAsInfixAnotType = ctx.requiredClassRef("scala.annotation.showAsInfix")
-  def ShowAsInfixAnnot(implicit ctx: Context) = ShowAsInfixAnotType.symbol.asClass
+  lazy val AliasAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.Alias")
+  def AliasAnnot(implicit ctx: Context): ClassSymbol = AliasAnnotType.symbol.asClass
+  lazy val AnnotationDefaultAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.AnnotationDefault")
+  def AnnotationDefaultAnnot(implicit ctx: Context): ClassSymbol = AnnotationDefaultAnnotType.symbol.asClass
+  lazy val BodyAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.Body")
+  def BodyAnnot(implicit ctx: Context): ClassSymbol = BodyAnnotType.symbol.asClass
+  lazy val ChildAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.Child")
+  def ChildAnnot(implicit ctx: Context): ClassSymbol = ChildAnnotType.symbol.asClass
+  lazy val CovariantBetweenAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.CovariantBetween")
+  def CovariantBetweenAnnot(implicit ctx: Context): ClassSymbol = CovariantBetweenAnnotType.symbol.asClass
+  lazy val ContravariantBetweenAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.ContravariantBetween")
+  def ContravariantBetweenAnnot(implicit ctx: Context): ClassSymbol = ContravariantBetweenAnnotType.symbol.asClass
+  lazy val DeprecatedAnnotType: TypeRef = ctx.requiredClassRef("scala.deprecated")
+  def DeprecatedAnnot(implicit ctx: Context): ClassSymbol = DeprecatedAnnotType.symbol.asClass
+  lazy val ImplicitAmbiguousAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.implicitAmbiguous")
+  def ImplicitAmbiguousAnnot(implicit ctx: Context): ClassSymbol = ImplicitAmbiguousAnnotType.symbol.asClass
+  lazy val ImplicitNotFoundAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.implicitNotFound")
+  def ImplicitNotFoundAnnot(implicit ctx: Context): ClassSymbol = ImplicitNotFoundAnnotType.symbol.asClass
+  lazy val ForceInlineAnnotType: TypeRef = ctx.requiredClassRef("scala.forceInline")
+  def ForceInlineAnnot(implicit ctx: Context): ClassSymbol = ForceInlineAnnotType.symbol.asClass
+  lazy val InlineParamAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.InlineParam")
+  def InlineParamAnnot(implicit ctx: Context): ClassSymbol = InlineParamAnnotType.symbol.asClass
+  lazy val InvariantBetweenAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.InvariantBetween")
+  def InvariantBetweenAnnot(implicit ctx: Context): ClassSymbol = InvariantBetweenAnnotType.symbol.asClass
+  lazy val MigrationAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.migration")
+  def MigrationAnnot(implicit ctx: Context): ClassSymbol = MigrationAnnotType.symbol.asClass
+  lazy val NativeAnnotType: TypeRef                   = ctx.requiredClassRef("scala.native")
+  def NativeAnnot(implicit ctx: Context): ClassSymbol = NativeAnnotType.symbol.asClass
+  lazy val RepeatedAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.Repeated")
+  def RepeatedAnnot(implicit ctx: Context): ClassSymbol = RepeatedAnnotType.symbol.asClass
+  lazy val SourceFileAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.SourceFile")
+  def SourceFileAnnot(implicit ctx: Context): ClassSymbol = SourceFileAnnotType.symbol.asClass
+  lazy val ScalaSignatureAnnotType: TypeRef = ctx.requiredClassRef("scala.reflect.ScalaSignature")
+  def ScalaSignatureAnnot(implicit ctx: Context): ClassSymbol = ScalaSignatureAnnotType.symbol.asClass
+  lazy val ScalaLongSignatureAnnotType: TypeRef = ctx.requiredClassRef("scala.reflect.ScalaLongSignature")
+  def ScalaLongSignatureAnnot(implicit ctx: Context): ClassSymbol = ScalaLongSignatureAnnotType.symbol.asClass
+  lazy val ScalaStrictFPAnnotType: TypeRef            = ctx.requiredClassRef("scala.annotation.strictfp")
+  def ScalaStrictFPAnnot(implicit ctx: Context): ClassSymbol = ScalaStrictFPAnnotType.symbol.asClass
+  lazy val ScalaStaticAnnotType: TypeRef            = ctx.requiredClassRef("scala.annotation.static")
+  def ScalaStaticAnnot(implicit ctx: Context): ClassSymbol = ScalaStaticAnnotType.symbol.asClass
+  lazy val SerialVersionUIDAnnotType: TypeRef         = ctx.requiredClassRef("scala.SerialVersionUID")
+  def SerialVersionUIDAnnot(implicit ctx: Context): ClassSymbol = SerialVersionUIDAnnotType.symbol.asClass
+  lazy val TASTYSignatureAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.TASTYSignature")
+  def TASTYSignatureAnnot(implicit ctx: Context): ClassSymbol = TASTYSignatureAnnotType.symbol.asClass
+  lazy val TASTYLongSignatureAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.TASTYLongSignature")
+  def TASTYLongSignatureAnnot(implicit ctx: Context): ClassSymbol = TASTYLongSignatureAnnotType.symbol.asClass
+  lazy val TailrecAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.tailrec")
+  def TailrecAnnot(implicit ctx: Context): ClassSymbol = TailrecAnnotType.symbol.asClass
+  lazy val SwitchAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.switch")
+  def SwitchAnnot(implicit ctx: Context): ClassSymbol = SwitchAnnotType.symbol.asClass
+  lazy val ThrowsAnnotType: TypeRef = ctx.requiredClassRef("scala.throws")
+  def ThrowsAnnot(implicit ctx: Context): ClassSymbol = ThrowsAnnotType.symbol.asClass
+  lazy val TransientAnnotType: TypeRef                = ctx.requiredClassRef("scala.transient")
+  def TransientAnnot(implicit ctx: Context): ClassSymbol = TransientAnnotType.symbol.asClass
+  lazy val UncheckedAnnotType: TypeRef = ctx.requiredClassRef("scala.unchecked")
+  def UncheckedAnnot(implicit ctx: Context): ClassSymbol = UncheckedAnnotType.symbol.asClass
+  lazy val UncheckedStableAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedStable")
+  def UncheckedStableAnnot(implicit ctx: Context): ClassSymbol = UncheckedStableAnnotType.symbol.asClass
+  lazy val UncheckedVarianceAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.unchecked.uncheckedVariance")
+  def UncheckedVarianceAnnot(implicit ctx: Context): ClassSymbol = UncheckedVarianceAnnotType.symbol.asClass
+  lazy val VolatileAnnotType: TypeRef = ctx.requiredClassRef("scala.volatile")
+  def VolatileAnnot(implicit ctx: Context): ClassSymbol = VolatileAnnotType.symbol.asClass
+  lazy val FieldMetaAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.meta.field")
+  def FieldMetaAnnot(implicit ctx: Context): ClassSymbol = FieldMetaAnnotType.symbol.asClass
+  lazy val GetterMetaAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.meta.getter")
+  def GetterMetaAnnot(implicit ctx: Context): ClassSymbol = GetterMetaAnnotType.symbol.asClass
+  lazy val SetterMetaAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.meta.setter")
+  def SetterMetaAnnot(implicit ctx: Context): ClassSymbol = SetterMetaAnnotType.symbol.asClass
+  lazy val ShowAsInfixAnotType: TypeRef = ctx.requiredClassRef("scala.annotation.showAsInfix")
+  def ShowAsInfixAnnot(implicit ctx: Context): ClassSymbol = ShowAsInfixAnotType.symbol.asClass
 
   // convenient one-parameter method types
-  def methOfAny(tp: Type) = MethodType(List(AnyType), tp)
-  def methOfAnyVal(tp: Type) = MethodType(List(AnyValType), tp)
-  def methOfAnyRef(tp: Type) = MethodType(List(ObjectType), tp)
+  def methOfAny(tp: Type): MethodType = MethodType(List(AnyType), tp)
+  def methOfAnyVal(tp: Type): MethodType = MethodType(List(AnyValType), tp)
+  def methOfAnyRef(tp: Type): MethodType = MethodType(List(ObjectType), tp)
 
   // Derived types
 
-  def RepeatedParamType = RepeatedParamClass.typeRef
+  def RepeatedParamType: TypeRef = RepeatedParamClass.typeRef
 
-  def ClassType(arg: Type)(implicit ctx: Context) = {
+  def ClassType(arg: Type)(implicit ctx: Context): Type = {
     val ctype = ClassClass.typeRef
     if (ctx.phase.erasedTypes) ctype else ctype.appliedTo(arg)
   }
 
   /** The enumeration type, goven a value of the enumeration */
-  def EnumType(sym: Symbol)(implicit ctx: Context) =
+  def EnumType(sym: Symbol)(implicit ctx: Context): TypeRef =
     // given (in java): "class A { enum E { VAL1 } }"
     //  - sym: the symbol of the actual enumeration value (VAL1)
     //  - .owner: the ModuleClassSymbol of the enumeration (object E)
@@ -834,9 +833,9 @@ class Definitions {
     sym.owner.linkedClass.typeRef
 
   object FunctionOf {
-    def apply(args: List[Type], resultType: Type, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context) =
+    def apply(args: List[Type], resultType: Type, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): Type =
       FunctionType(args.length, isImplicit, isErased).appliedTo(args ::: resultType :: Nil)
-    def unapply(ft: Type)(implicit ctx: Context) = {
+    def unapply(ft: Type)(implicit ctx: Context): Option[(List[Type], Type, Boolean, Boolean)] = {
       val tsym = ft.typeSymbol
       if (isFunctionClass(tsym)) {
         val targs = ft.dealias.argInfos
@@ -848,9 +847,9 @@ class Definitions {
   }
 
   object PartialFunctionOf {
-    def apply(arg: Type, result: Type)(implicit ctx: Context) =
+    def apply(arg: Type, result: Type)(implicit ctx: Context): Type =
       PartialFunctionType.appliedTo(arg :: result :: Nil)
-    def unapply(pft: Type)(implicit ctx: Context) = {
+    def unapply(pft: Type)(implicit ctx: Context): Option[(Type, List[Type])] = {
       if (pft.isRef(PartialFunctionClass)) {
         val targs = pft.dealias.argInfos
         if (targs.length == 2) Some((targs.head, targs.tail)) else None
@@ -860,7 +859,7 @@ class Definitions {
   }
 
   object ArrayOf {
-    def apply(elem: Type)(implicit ctx: Context) =
+    def apply(elem: Type)(implicit ctx: Context): Type =
       if (ctx.erasedTypes) JavaArrayType(elem)
       else ArrayType.appliedTo(elem :: Nil)
     def unapply(tp: Type)(implicit ctx: Context): Option[Type] = tp.dealias match {
@@ -895,20 +894,20 @@ class Definitions {
     }
   }
 
-  final def isTypelevel_S(sym: Symbol)(implicit ctx: Context) =
+  final def isTypelevel_S(sym: Symbol)(implicit ctx: Context): Boolean =
     sym.name == tpnme.S && sym.owner == TypelevelPackageObject
 
   // ----- Symbol sets ---------------------------------------------------
 
-  lazy val AbstractFunctionType = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0)
-  val AbstractFunctionClassPerRun = new PerRun[Array[Symbol]](implicit ctx => AbstractFunctionType.map(_.symbol.asClass))
-  def AbstractFunctionClass(n: Int)(implicit ctx: Context) = AbstractFunctionClassPerRun()(ctx)(n)
+  lazy val AbstractFunctionType: Array[TypeRef] = mkArityArray("scala.runtime.AbstractFunction", MaxImplementedFunctionArity, 0)
+  val AbstractFunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun[Array[Symbol]](implicit ctx => AbstractFunctionType.map(_.symbol.asClass))
+  def AbstractFunctionClass(n: Int)(implicit ctx: Context): Symbol = AbstractFunctionClassPerRun()(ctx)(n)
   private lazy val ImplementedFunctionType = mkArityArray("scala.Function", MaxImplementedFunctionArity, 0)
-  def FunctionClassPerRun = new PerRun[Array[Symbol]](implicit ctx => ImplementedFunctionType.map(_.symbol.asClass))
+  def FunctionClassPerRun: PerRun[Array[Symbol]] = new PerRun[Array[Symbol]](implicit ctx => ImplementedFunctionType.map(_.symbol.asClass))
 
-  lazy val TupleType = mkArityArray("scala.Tuple", MaxTupleArity, 1)
+  lazy val TupleType: Array[TypeRef] = mkArityArray("scala.Tuple", MaxTupleArity, 1)
 
-  def FunctionClass(n: Int, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context) =
+  def FunctionClass(n: Int, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): Symbol =
     if (isImplicit && isErased)
       ctx.requiredClass("scala.ErasedImplicitFunction" + n.toString)
     else if (isImplicit)
@@ -920,8 +919,8 @@ class Definitions {
     else
       ctx.requiredClass("scala.Function" + n.toString)
 
-    lazy val Function0_applyR = ImplementedFunctionType(0).symbol.requiredMethodRef(nme.apply)
-    def Function0_apply(implicit ctx: Context) = Function0_applyR.symbol
+    lazy val Function0_applyR: TermRef = ImplementedFunctionType(0).symbol.requiredMethodRef(nme.apply)
+    def Function0_apply(implicit ctx: Context): Symbol = Function0_applyR.symbol
 
   def FunctionType(n: Int, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): TypeRef =
     if (n <= MaxImplementedFunctionArity && (!isImplicit || ctx.erasedTypes) && !isErased) ImplementedFunctionType(n)
@@ -941,9 +940,9 @@ class Definitions {
       name.length > prefix.length &&
       name.drop(prefix.length).forall(_.isDigit))
 
-  def isBottomClass(cls: Symbol) =
+  def isBottomClass(cls: Symbol): Boolean =
     cls == NothingClass || cls == NullClass
-  def isBottomType(tp: Type) =
+  def isBottomType(tp: Type): Boolean =
     tp.derivesFrom(NothingClass) || tp.derivesFrom(NullClass)
 
   /** Is a function class.
@@ -952,37 +951,37 @@ class Definitions {
    *   - ErasedFunctionN for N > 0
    *   - ErasedImplicitFunctionN for N > 0
    */
-  def isFunctionClass(cls: Symbol) = scalaClassName(cls).isFunction
+  def isFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isFunction
 
   /** Is an implicit function class.
    *   - ImplicitFunctionN for N >= 0
    *   - ErasedImplicitFunctionN for N > 0
    */
-  def isImplicitFunctionClass(cls: Symbol) = scalaClassName(cls).isImplicitFunction
+  def isImplicitFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isImplicitFunction
 
   /** Is an erased function class.
    *   - ErasedFunctionN for N > 0
    *   - ErasedImplicitFunctionN for N > 0
    */
-  def isErasedFunctionClass(cls: Symbol) = scalaClassName(cls).isErasedFunction
+  def isErasedFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isErasedFunction
 
   /** Is a class that will be erased to FunctionXXL
    *   - FunctionN for N >= 22
    *   - ImplicitFunctionN for N >= 22
    */
-  def isXXLFunctionClass(cls: Symbol) = scalaClassName(cls).functionArity > MaxImplementedFunctionArity
+  def isXXLFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).functionArity > MaxImplementedFunctionArity
 
   /** Is a synthetic function class
    *    - FunctionN for N > 22
    *    - ImplicitFunctionN for N > 0
    */
-  def isSyntheticFunctionClass(cls: Symbol) = scalaClassName(cls).isSyntheticFunction
+  def isSyntheticFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isSyntheticFunction
 
-  def isAbstractFunctionClass(cls: Symbol) = isVarArityClass(cls, str.AbstractFunction)
-  def isTupleClass(cls: Symbol) = isVarArityClass(cls, str.Tuple)
-  def isProductClass(cls: Symbol) = isVarArityClass(cls, str.Product)
+  def isAbstractFunctionClass(cls: Symbol): Boolean = isVarArityClass(cls, str.AbstractFunction)
+  def isTupleClass(cls: Symbol): Boolean = isVarArityClass(cls, str.Tuple)
+  def isProductClass(cls: Symbol): Boolean = isVarArityClass(cls, str.Product)
 
-  def isScalaShadowingPackageClass(cls: Symbol) =
+  def isScalaShadowingPackageClass(cls: Symbol): Boolean =
     cls.name == tpnme.scalaShadowing && cls.owner == RootClass
 
   /** Returns the erased class of the function class `cls`
@@ -1023,32 +1022,32 @@ class Definitions {
     Set("Predef$", "DeprecatedPredef", "LowPriorityImplicits").map(_.toTypeName.unmangleClassName)
 
   /** Is `cls` the predef module class, or a class inherited by Predef? */
-  def isPredefClass(cls: Symbol) =
+  def isPredefClass(cls: Symbol): Boolean =
     (cls.owner eq ScalaPackageClass) && predefClassNames.contains(cls.name)
 
-  val StaticRootImportFns = List[() => TermRef](
+  val StaticRootImportFns: List[() => TermRef] = List[() => TermRef](
     () => JavaLangPackageVal.termRef,
     () => ScalaPackageVal.termRef
   )
 
-  val PredefImportFns = List[() => TermRef](
+  val PredefImportFns: List[() => TermRef] = List[() => TermRef](
     () => ScalaPredefModuleRef,
     () => DottyPredefModuleRef
   )
 
-  lazy val RootImportFns =
+  lazy val RootImportFns: List[() => TermRef] =
     if (ctx.settings.YnoImports.value) List.empty[() => TermRef]
     else if (ctx.settings.YnoPredef.value) StaticRootImportFns
     else StaticRootImportFns ++ PredefImportFns
 
-  lazy val ShadowableImportNames = Set("Predef", "DottyPredef").map(_.toTermName)
-  lazy val RootImportTypes = RootImportFns.map(_())
+  lazy val ShadowableImportNames: Set[TermName] = Set("Predef", "DottyPredef").map(_.toTermName)
+  lazy val RootImportTypes: List[TermRef] = RootImportFns.map(_())
 
   /** Modules whose members are in the default namespace and their module classes */
   lazy val UnqualifiedOwnerTypes: Set[NamedType] =
     RootImportTypes.toSet[NamedType] ++ RootImportTypes.map(_.symbol.moduleClass.typeRef)
 
-  lazy val NotRuntimeClasses = Set[Symbol](AnyClass, AnyValClass, NullClass, NothingClass)
+  lazy val NotRuntimeClasses: Set[Symbol] = Set(AnyClass, AnyValClass, NullClass, NothingClass)
 
   /** Classes that are known not to have an initializer irrespective of
    *  whether NoInits is set. Note: FunctionXXLClass is in this set
@@ -1060,34 +1059,34 @@ class Definitions {
    *  trait gets screwed up. Therefore, it is mandatory that FunctionXXL
    *  is treated as a NoInit trait.
    */
-  lazy val NoInitClasses = NotRuntimeClasses + FunctionXXLClass
+  lazy val NoInitClasses: Set[Symbol] = NotRuntimeClasses + FunctionXXLClass
 
-  def isPolymorphicAfterErasure(sym: Symbol) =
+  def isPolymorphicAfterErasure(sym: Symbol): Boolean =
      (sym eq Any_isInstanceOf) || (sym eq Any_asInstanceOf)
 
-  def isTupleType(tp: Type)(implicit ctx: Context) = {
+  def isTupleType(tp: Type)(implicit ctx: Context): Boolean = {
     val arity = tp.dealias.argInfos.length
     arity <= MaxTupleArity && TupleType(arity) != null && (tp isRef TupleType(arity).symbol)
   }
 
-  def tupleType(elems: List[Type]) = {
+  def tupleType(elems: List[Type]): Type = {
     TupleType(elems.size).appliedTo(elems)
   }
 
-  def isProductSubType(tp: Type)(implicit ctx: Context) =
+  def isProductSubType(tp: Type)(implicit ctx: Context): Boolean =
     tp.derivesFrom(ProductType.symbol)
 
   /** Is `tp` (an alias) of either a scala.FunctionN or a scala.ImplicitFunctionN
    *  instance?
    */
-  def isNonDepFunctionType(tp: Type)(implicit ctx: Context) = {
+  def isNonDepFunctionType(tp: Type)(implicit ctx: Context): Boolean = {
     val arity = functionArity(tp)
     val sym = tp.dealias.typeSymbol
     arity >= 0 && isFunctionClass(sym) && tp.isRef(FunctionType(arity, sym.name.isImplicitFunction, sym.name.isErasedFunction).typeSymbol)
   }
 
   /** Is `tp` a representation of a (possibly depenent) function type or an alias of such? */
-  def isFunctionType(tp: Type)(implicit ctx: Context) =
+  def isFunctionType(tp: Type)(implicit ctx: Context): Boolean =
     isNonDepFunctionType(tp.dropDependentRefinement)
 
   // Specialized type parameters defined for scala.Function{0,1,2}.
@@ -1102,18 +1101,18 @@ class Definitions {
   lazy val Function2SpecializedReturnTypes: collection.Set[TypeRef] =
     Function1SpecializedReturnTypes
 
-  lazy val Function1SpecializedParamClasses =
-    new PerRun[collection.Set[Symbol]](implicit ctx => Function1SpecializedParamTypes.map(_.symbol))
-  lazy val Function2SpecializedParamClasses =
-    new PerRun[collection.Set[Symbol]](implicit ctx => Function2SpecializedParamTypes.map(_.symbol))
-  lazy val Function0SpecializedReturnClasses =
-    new PerRun[collection.Set[Symbol]](implicit ctx => Function0SpecializedReturnTypes.map(_.symbol))
-  lazy val Function1SpecializedReturnClasses =
-    new PerRun[collection.Set[Symbol]](implicit ctx => Function1SpecializedReturnTypes.map(_.symbol))
-  lazy val Function2SpecializedReturnClasses =
-    new PerRun[collection.Set[Symbol]](implicit ctx => Function2SpecializedReturnTypes.map(_.symbol))
-
-  def isSpecializableFunction(cls: ClassSymbol, paramTypes: List[Type], retType: Type)(implicit ctx: Context) =
+  lazy val Function1SpecializedParamClasses: PerRun[collection.Set[Symbol]] =
+    new PerRun(implicit ctx => Function1SpecializedParamTypes.map(_.symbol))
+  lazy val Function2SpecializedParamClasses: PerRun[collection.Set[Symbol]] =
+    new PerRun(implicit ctx => Function2SpecializedParamTypes.map(_.symbol))
+  lazy val Function0SpecializedReturnClasses: PerRun[collection.Set[Symbol]] =
+    new PerRun(implicit ctx => Function0SpecializedReturnTypes.map(_.symbol))
+  lazy val Function1SpecializedReturnClasses: PerRun[collection.Set[Symbol]] =
+    new PerRun(implicit ctx => Function1SpecializedReturnTypes.map(_.symbol))
+  lazy val Function2SpecializedReturnClasses: PerRun[collection.Set[Symbol]] =
+    new PerRun(implicit ctx => Function2SpecializedReturnTypes.map(_.symbol))
+
+  def isSpecializableFunction(cls: ClassSymbol, paramTypes: List[Type], retType: Type)(implicit ctx: Context): Boolean =
     paramTypes.length <= 2 && cls.derivesFrom(FunctionClass(paramTypes.length)) && (paramTypes match {
       case Nil =>
         Function0SpecializedReturnClasses().contains(retType.typeSymbol)
@@ -1128,7 +1127,7 @@ class Definitions {
         false
     })
 
-  def functionArity(tp: Type)(implicit ctx: Context) = tp.dealias.argInfos.length - 1
+  def functionArity(tp: Type)(implicit ctx: Context): Int = tp.dealias.argInfos.length - 1
 
   /** Return underlying immplicit function type (i.e. instance of an ImplicitFunctionN class)
    *  or NoType if none exists. The following types are considered as underlying types:
@@ -1149,11 +1148,11 @@ class Definitions {
   def isImplicitFunctionType(tp: Type)(implicit ctx: Context): Boolean =
     asImplicitFunctionType(tp).exists
 
-  def isErasedFunctionType(tp: Type)(implicit ctx: Context) =
+  def isErasedFunctionType(tp: Type)(implicit ctx: Context): Boolean =
     isFunctionType(tp) && tp.dealias.typeSymbol.name.isErasedFunction
 
   /** A whitelist of Scala-2 classes that are known to be pure */
-  def isAssuredNoInits(sym: Symbol) =
+  def isAssuredNoInits(sym: Symbol): Boolean =
     (sym `eq` SomeClass) || isTupleClass(sym)
 
   /** If `cls` is Tuple1..Tuple22, add the corresponding *: type as last parent to `parents` */
@@ -1179,16 +1178,16 @@ class Definitions {
     }
   }
 
-  lazy val ScalaNumericValueTypeList = List(
+  lazy val ScalaNumericValueTypeList: List[TypeRef] = List(
     ByteType, ShortType, CharType, IntType, LongType, FloatType, DoubleType)
 
   private lazy val ScalaNumericValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypeList.toSet
   private lazy val ScalaValueTypes: collection.Set[TypeRef] = ScalaNumericValueTypes + UnitType + BooleanType
   private lazy val ScalaBoxedTypes = ScalaValueTypes map (t => boxedTypes(t.name))
 
-  val ScalaNumericValueClasses = new PerRun[collection.Set[Symbol]](implicit ctx => ScalaNumericValueTypes.map(_.symbol))
-  val ScalaValueClasses        = new PerRun[collection.Set[Symbol]](implicit ctx => ScalaValueTypes.map(_.symbol))
-  val ScalaBoxedClasses        = new PerRun[collection.Set[Symbol]](implicit ctx => ScalaBoxedTypes.map(_.symbol))
+  val ScalaNumericValueClasses: PerRun[collection.Set[Symbol]] = new PerRun(implicit ctx => ScalaNumericValueTypes.map(_.symbol))
+  val ScalaValueClasses: PerRun[collection.Set[Symbol]]        = new PerRun(implicit ctx => ScalaValueTypes.map(_.symbol))
+  val ScalaBoxedClasses: PerRun[collection.Set[Symbol]]        = new PerRun(implicit ctx => ScalaBoxedTypes.map(_.symbol))
 
   private val boxedTypes = mutable.Map[TypeName, TypeRef]()
   private val valueTypeEnc = mutable.Map[TypeName, PrimitiveClassEnc]()
@@ -1221,27 +1220,27 @@ class Definitions {
 
   type PrimitiveClassEnc = Int
 
-  val ByteEnc = 2
-  val ShortEnc = ByteEnc * 3
-  val CharEnc = 5
-  val IntEnc = ShortEnc * CharEnc
-  val LongEnc = IntEnc * 7
-  val FloatEnc = LongEnc * 11
-  val DoubleEnc = FloatEnc * 13
-  val BooleanEnc = 17
-  val UnitEnc = 19
-
-  def isValueSubType(tref1: TypeRef, tref2: TypeRef)(implicit ctx: Context) =
+  val ByteEnc: Int = 2
+  val ShortEnc: Int = ByteEnc * 3
+  val CharEnc: Int = 5
+  val IntEnc: Int = ShortEnc * CharEnc
+  val LongEnc: Int = IntEnc * 7
+  val FloatEnc: Int = LongEnc * 11
+  val DoubleEnc: Int = FloatEnc * 13
+  val BooleanEnc: Int = 17
+  val UnitEnc: Int = 19
+
+  def isValueSubType(tref1: TypeRef, tref2: TypeRef)(implicit ctx: Context): Boolean =
     valueTypeEnc(tref2.name) % valueTypeEnc(tref1.name) == 0
-  def isValueSubClass(sym1: Symbol, sym2: Symbol) =
+  def isValueSubClass(sym1: Symbol, sym2: Symbol): Boolean =
     valueTypeEnc(sym2.asClass.name) % valueTypeEnc(sym1.asClass.name) == 0
 
-  lazy val erasedToObject = Set[Symbol](AnyClass, AnyValClass, TupleClass, NonEmptyTupleClass, SingletonClass)
+  lazy val erasedToObject: Set[Symbol] = Set(AnyClass, AnyValClass, TupleClass, NonEmptyTupleClass, SingletonClass)
 
   // ----- Initialization ---------------------------------------------------
 
   /** Lists core classes that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
-  lazy val syntheticScalaClasses = List(
+  lazy val syntheticScalaClasses: List[TypeSymbol] = List(
     AnyClass,
     AnyRefAlias,
     AnyKindClass,
@@ -1253,19 +1252,19 @@ class Definitions {
     SingletonClass,
     EqualsPatternClass)
 
-  lazy val syntheticCoreClasses = syntheticScalaClasses ++ List(
+  lazy val syntheticCoreClasses: List[Symbol] = syntheticScalaClasses ++ List(
     EmptyPackageVal,
     OpsPackageClass)
 
   /** Lists core methods that don't have underlying bytecode, but are synthesized on-the-fly in every reflection universe */
-  lazy val syntheticCoreMethods =
+  lazy val syntheticCoreMethods: List[TermSymbol] =
     AnyMethods ++ ObjectMethods ++ List(String_+, throwMethod)
 
   lazy val reservedScalaClassNames: Set[Name] = syntheticScalaClasses.map(_.name).toSet
 
   private[this] var isInitialized = false
 
-  def init()(implicit ctx: Context) = {
+  def init()(implicit ctx: Context): Unit = {
     this.ctx = ctx
     if (!isInitialized) {
       // Enter all symbols from the scalaShadowing package in the scala package
diff --git a/compiler/src/dotty/tools/dotc/core/DenotTransformers.scala b/compiler/src/dotty/tools/dotc/core/DenotTransformers.scala
index 5ec1620a77f1..f8ea4fde1104 100644
--- a/compiler/src/dotty/tools/dotc/core/DenotTransformers.scala
+++ b/compiler/src/dotty/tools/dotc/core/DenotTransformers.scala
@@ -8,8 +8,6 @@ import Types._
 import Symbols._
 import Denotations._
 import Phases._
-import java.lang.AssertionError
-import dotty.tools.dotc.util.DotClass
 
 object DenotTransformers {
 
@@ -22,7 +20,7 @@ object DenotTransformers {
   trait DenotTransformer extends Phase {
 
     /** The last phase during which the transformed denotations are valid */
-    def lastPhaseId(implicit ctx: Context) = ctx.base.nextDenotTransformerId(id + 1)
+    def lastPhaseId(implicit ctx: Context): Int = ctx.base.nextDenotTransformerId(id + 1)
 
     /** The validity period of the transformed denotations 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 2100db069eb0..c4357138abad 100644
--- a/compiler/src/dotty/tools/dotc/core/Denotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/Denotations.scala
@@ -2,10 +2,9 @@ package dotty.tools
 package dotc
 package core
 
-import SymDenotations.{ SymDenotation, ClassDenotation, NoDenotation }
+import SymDenotations.{ SymDenotation, ClassDenotation, NoDenotation, LazyType }
 import Contexts.{Context, ContextBase}
 import Names._
-import NameOps._
 import NameKinds._
 import StdNames._
 import Symbols.NoSymbol
@@ -15,15 +14,12 @@ import Periods._
 import Flags._
 import DenotTransformers._
 import Decorators._
-import dotc.transform.Erasure
 import printing.Texts._
 import printing.Printer
 import io.AbstractFile
 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
@@ -201,7 +197,7 @@ object Denotations {
     def isTerm: Boolean = !isType
 
     /** Is this denotation overloaded? */
-    final def isOverloaded = isInstanceOf[MultiDenotation]
+    final def isOverloaded: Boolean = isInstanceOf[MultiDenotation]
 
     /** Denotation points to unique symbol; false for overloaded denotations
      * and JointRef denotations.
@@ -233,7 +229,7 @@ object Denotations {
     def mapInfo(f: Type => Type)(implicit ctx: Context): Denotation
 
     /** If this denotation does not exist, fallback to alternative */
-    final def orElse(that: => Denotation) = if (this.exists) this else that
+    final def orElse(that: => Denotation): Denotation = if (this.exists) this else that
 
     /** The set of alternative single-denotations making up this denotation */
     final def alternatives: List[SingleDenotation] = altsWith(alwaysTrue)
@@ -672,8 +668,8 @@ object Denotations {
       }
     }
 
-    final def asSingleDenotation = asInstanceOf[SingleDenotation]
-    final def asSymDenotation = asInstanceOf[SymDenotation]
+    final def asSingleDenotation: SingleDenotation = asInstanceOf[SingleDenotation]
+    final def asSymDenotation: SymDenotation = asInstanceOf[SymDenotation]
 
     def toText(printer: Printer): Text = printer.toText(this)
 
@@ -709,7 +705,7 @@ object Denotations {
     def mapInfo(f: Type => Type)(implicit ctx: Context): SingleDenotation =
       derivedSingleDenotation(symbol, f(info))
 
-    def orElse(that: => SingleDenotation) = if (this.exists) this else that
+    def orElse(that: => SingleDenotation): SingleDenotation = if (this.exists) this else that
 
     def altsWith(p: Symbol => Boolean): List[SingleDenotation] =
       if (exists && p(symbol)) this :: Nil else Nil
@@ -754,8 +750,8 @@ object Denotations {
 
     private[this] var myValidFor: Period = Nowhere
 
-    def validFor = myValidFor
-    def validFor_=(p: Period) = {
+    def validFor: Period = myValidFor
+    def validFor_=(p: Period): Unit = {
       myValidFor = p
       symbol.invalidateDenotCache()
     }
@@ -1020,7 +1016,7 @@ object Denotations {
       nextInRun = newd
     }
 
-    def staleSymbolError(implicit ctx: Context) =
+    def staleSymbolError(implicit ctx: Context): Nothing =
       throw new StaleSymbol(staleSymbolMsg)
 
     def staleSymbolMsg(implicit ctx: Context): String = {
@@ -1052,7 +1048,7 @@ object Denotations {
      */
     def showDcl(implicit ctx: Context): String = ctx.printer.dclText(this).show
 
-    override def toString =
+    override def toString: String =
       if (symbol == NoSymbol) symbol.toString
       else s"<SingleDenotation of type $infoOrCompleter>"
 
@@ -1071,8 +1067,8 @@ object Denotations {
 
     // ------ PreDenotation ops ----------------------------------------------
 
-    final def first = this
-    final def last = this
+    final def first: SingleDenotation = this
+    final def last: SingleDenotation = this
 
     final def matches(other: SingleDenotation)(implicit ctx: Context): Boolean = {
       val d = signature.matchDegree(other.signature)
@@ -1110,7 +1106,7 @@ object Denotations {
 
   abstract class NonSymSingleDenotation(symbol: Symbol, initInfo: Type) extends SingleDenotation(symbol, initInfo) {
     def infoOrCompleter: Type = initInfo
-    def isType = infoOrCompleter.isInstanceOf[TypeType]
+    def isType: Boolean = infoOrCompleter.isInstanceOf[TypeType]
   }
 
   class UniqueRefDenotation(
@@ -1127,13 +1123,13 @@ object Denotations {
     initInfo: Type,
     initValidFor: Period) extends NonSymSingleDenotation(symbol, initInfo) {
     validFor = initValidFor
-    override def hasUniqueSym = false
+    override def hasUniqueSym: Boolean = false
     protected def newLikeThis(s: Symbol, i: Type): SingleDenotation = new JointRefDenotation(s, i, validFor)
   }
 
   class ErrorDenotation(implicit ctx: Context) extends NonSymSingleDenotation(NoSymbol, NoType) {
-    override def exists = false
-    override def hasUniqueSym = false
+    override def exists: Boolean = false
+    override def hasUniqueSym: Boolean = false
     validFor = Period.allInRun(ctx.runId)
     protected def newLikeThis(s: Symbol, i: Type): SingleDenotation = this
   }
@@ -1179,8 +1175,8 @@ object Denotations {
     def denot2: PreDenotation
 
     assert(denot1.exists && denot2.exists, s"Union of non-existing denotations ($denot1) and ($denot2)")
-    def first = denot1.first
-    def last = denot2.last
+    def first: Denotation = denot1.first
+    def last: Denotation = denot2.last
     def matches(other: SingleDenotation)(implicit ctx: Context): Boolean =
       denot1.matches(other) || denot2.matches(other)
     def filterWithPredicate(p: SingleDenotation => Boolean): PreDenotation =
@@ -1191,16 +1187,16 @@ object Denotations {
       derivedUnion(denot1.mapInherited(owndenot, prevdenot, pre), denot2.mapInherited(owndenot, prevdenot, pre))
     def filterExcluded(excluded: FlagSet)(implicit ctx: Context): PreDenotation =
       derivedUnion(denot1.filterExcluded(excluded), denot2.filterExcluded(excluded))
-    protected def derivedUnion(denot1: PreDenotation, denot2: PreDenotation) =
+    protected def derivedUnion(denot1: PreDenotation, denot2: PreDenotation): PreDenotation =
       if ((denot1 eq this.denot1) && (denot2 eq this.denot2)) this
       else denot1 union denot2
   }
 
   final case class DenotUnion(denot1: PreDenotation, denot2: PreDenotation) extends MultiPreDenotation {
-    def exists = true
-    def toDenot(pre: Type)(implicit ctx: Context) =
+    def exists: Boolean = true
+    def toDenot(pre: Type)(implicit ctx: Context): Denotation =
       (denot1 toDenot pre) & (denot2 toDenot pre, pre)
-    def containsSym(sym: Symbol) =
+    def containsSym(sym: Symbol): Boolean =
       (denot1 containsSym sym) || (denot2 containsSym sym)
     type AsSeenFromResult = PreDenotation
     def computeAsSeenFrom(pre: Type)(implicit ctx: Context): PreDenotation =
@@ -1210,12 +1206,12 @@ object Denotations {
   /** An overloaded denotation consisting of the alternatives of both given denotations.
    */
   case class MultiDenotation(denot1: Denotation, denot2: Denotation) extends Denotation(NoSymbol, NoType) with MultiPreDenotation {
-    final def infoOrCompleter = multiHasNot("info")
-    final def validFor = denot1.validFor & denot2.validFor
-    final def isType = false
-    final def hasUniqueSym = false
-    final def name(implicit ctx: Context) = denot1.name
-    final def signature(implicit ctx: Context) = Signature.OverloadedSignature
+    final def infoOrCompleter: Type = multiHasNot("info")
+    final def validFor: Period = denot1.validFor & denot2.validFor
+    final def isType: Boolean = false
+    final def hasUniqueSym: Boolean = false
+    final def name(implicit ctx: Context): Name = denot1.name
+    final def signature(implicit ctx: Context): Signature = Signature.OverloadedSignature
     def atSignature(sig: Signature, site: Type, relaxed: Boolean)(implicit ctx: Context): Denotation =
       if (sig eq Signature.OverloadedSignature) this
       else derivedUnionDenotation(denot1.atSignature(sig, site, relaxed), denot2.atSignature(sig, site, relaxed))
@@ -1252,7 +1248,7 @@ object Denotations {
     type AsSeenFromResult = Denotation
     def computeAsSeenFrom(pre: Type)(implicit ctx: Context): Denotation =
       derivedUnionDenotation(denot1.asSeenFrom(pre), denot2.asSeenFrom(pre))
-    override def toString = alternatives.mkString(" <and> ")
+    override def toString: String = alternatives.mkString(" <and> ")
 
     private def multiHasNot(op: String): Nothing =
       throw new UnsupportedOperationException(
@@ -1329,6 +1325,6 @@ object Denotations {
   /** An exception for accessing symbols that are no longer valid in current run */
   class StaleSymbol(msg: => String) extends Exception {
     util.Stats.record("stale symbol")
-    override def getMessage() = msg
+    override def getMessage(): String = msg
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/Flags.scala b/compiler/src/dotty/tools/dotc/core/Flags.scala
index 2cdceeec4e01..f9736296524b 100644
--- a/compiler/src/dotty/tools/dotc/core/Flags.scala
+++ b/compiler/src/dotty/tools/dotc/core/Flags.scala
@@ -28,10 +28,10 @@ object Flags {
       }
 
     /** The intersection of this flag set and the given flag set */
-    def & (that: FlagSet) = FlagSet(bits & that.bits)
+    def & (that: FlagSet): FlagSet = FlagSet(bits & that.bits)
 
     /** The intersection of this flag set with the complement of the given flag set */
-    def &~ (that: FlagSet) = {
+    def &~ (that: FlagSet): FlagSet = {
       val tbits = bits & KINDFLAGS
       if ((tbits & that.bits) == 0) this
       else FlagSet(tbits | ((this.bits & ~that.bits) & ~KINDFLAGS))
@@ -65,25 +65,25 @@ object Flags {
      */
     def is(flags: FlagConjunction, butNot: FlagSet): Boolean = is(flags) && !is(butNot)
 
-    def isEmpty = (bits & ~KINDFLAGS) == 0
+    def isEmpty: Boolean = (bits & ~KINDFLAGS) == 0
 
     /** Is this flag set a subset of that one? */
-    def <= (that: FlagSet) = (bits & that.bits) == bits
+    def <= (that: FlagSet): Boolean = (bits & that.bits) == bits
 
     /** Does this flag set apply to terms? */
-    def isTermFlags = (bits & TERMS) != 0
+    def isTermFlags: Boolean = (bits & TERMS) != 0
 
     /** Does this flag set apply to terms? */
-    def isTypeFlags = (bits & TYPES) != 0
+    def isTypeFlags: Boolean = (bits & TYPES) != 0
 
     /** This flag set with all flags transposed to be type flags */
-    def toTypeFlags = if (bits == 0) this else FlagSet(bits & ~KINDFLAGS | TYPES)
+    def toTypeFlags: FlagSet = if (bits == 0) this else FlagSet(bits & ~KINDFLAGS | TYPES)
 
     /** This flag set with all flags transposed to be term flags */
-    def toTermFlags = if (bits == 0) this else FlagSet(bits & ~KINDFLAGS | TERMS)
+    def toTermFlags: FlagSet = if (bits == 0) this else FlagSet(bits & ~KINDFLAGS | TERMS)
 
     /** This flag set with all flags transposed to be common flags */
-    def toCommonFlags = if (bits == 0) this else FlagSet(bits | KINDFLAGS)
+    def toCommonFlags: FlagSet = if (bits == 0) this else FlagSet(bits | KINDFLAGS)
 
     /** The number of non-kind flags in this set */
     def numFlags: Int = java.lang.Long.bitCount(bits & ~KINDFLAGS)
@@ -116,7 +116,7 @@ object Flags {
     }
 
     /** The string representation of this flag set */
-    override def toString = flagStrings.mkString(" ")
+    override def toString: String = flagStrings.mkString(" ")
   }
 
   /** A class representing flag sets that should be tested
@@ -124,7 +124,7 @@ object Flags {
    *  `x is fc` tests whether `x` contains all flags in `fc`.
    */
   case class FlagConjunction(bits: Long) {
-    override def toString = FlagSet(bits).toString
+    override def toString: String = FlagSet(bits).toString
   }
 
   private final val TYPESHIFT = 2
@@ -192,255 +192,255 @@ object Flags {
     FlagConjunction((flags0 | union(flagss: _*)).bits)
   }
 
-  def commonFlags(flagss: FlagSet*) = union(flagss.map(_.toCommonFlags): _*)
+  def commonFlags(flagss: FlagSet*): FlagSet = union(flagss.map(_.toCommonFlags): _*)
 
   /** The empty flag set */
-  final val EmptyFlags = FlagSet(0)
+  final val EmptyFlags: FlagSet = FlagSet(0)
 
   /** The undefined flag set */
-  final val UndefinedFlags = FlagSet(~KINDFLAGS)
+  final val UndefinedFlags: FlagSet = FlagSet(~KINDFLAGS)
 
   // Available flags:
 
   /** Labeled with `private` modifier */
-  final val Private = commonFlag(2, "private")
-  final val PrivateTerm = Private.toTermFlags
-  final val PrivateType = Private.toTypeFlags
+  final val Private: FlagSet = commonFlag(2, "private")
+  final val PrivateTerm: FlagSet = Private.toTermFlags
+  final val PrivateType: FlagSet = Private.toTypeFlags
 
   /** Labeled with `protected` modifier */
-  final val Protected = commonFlag(3, "protected")
+  final val Protected: FlagSet = commonFlag(3, "protected")
 
   /** Labeled with `override` modifier */
-  final val Override = commonFlag(4, "override")
+  final val Override: FlagSet = commonFlag(4, "override")
 
   /** A declared, but not defined member */
-  final val Deferred = commonFlag(5, "<deferred>")
-  final val DeferredTerm = Deferred.toTermFlags
-  final val DeferredType = Deferred.toTypeFlags
+  final val Deferred: FlagSet = commonFlag(5, "<deferred>")
+  final val DeferredTerm: FlagSet = Deferred.toTermFlags
+  final val DeferredType: FlagSet = Deferred.toTypeFlags
 
   /** Labeled with `final` modifier */
-  final val Final = commonFlag(6, "final")
+  final val Final: FlagSet = commonFlag(6, "final")
 
   /** A method symbol. */
-  final val Method = termFlag(7, "<method>")
-  final val HigherKinded = typeFlag(7, "<higher kinded>")
+  final val Method: FlagSet = termFlag(7, "<method>")
+  final val HigherKinded: FlagSet = typeFlag(7, "<higher kinded>")
 
   /** A (term or type) parameter to a class or method */
-  final val Param     = commonFlag(8, "<param>")
-  final val TermParam = Param.toTermFlags
-  final val TypeParam = Param.toTypeFlags
+  final val Param: FlagSet     = commonFlag(8, "<param>")
+  final val TermParam: FlagSet = Param.toTermFlags
+  final val TypeParam: FlagSet = Param.toTypeFlags
 
   /** Labeled with `implicit` modifier (implicit value) */
-  final val ImplicitCommon = commonFlag(9, "implicit")
-  final val Implicit = ImplicitCommon.toTermFlags
+  final val ImplicitCommon: FlagSet = commonFlag(9, "implicit")
+  final val Implicit: FlagSet = ImplicitCommon.toTermFlags
 
   /** Labeled with `lazy` (a lazy val). */
-  final val Lazy = termFlag(10, "lazy")
+  final val Lazy: FlagSet = termFlag(10, "lazy")
 
   /** A trait */
-  final val Trait = typeFlag(10, "<trait>")
+  final val Trait: FlagSet = typeFlag(10, "<trait>")
 
-  final val LazyOrTrait = Lazy.toCommonFlags
+  final val LazyOrTrait: FlagSet = Lazy.toCommonFlags
 
   /** A value or variable accessor (getter or setter) */
-  final val Accessor = termFlag(11, "<accessor>")
+  final val Accessor: FlagSet = termFlag(11, "<accessor>")
 
   /** Labeled with `sealed` modifier (sealed class) */
-  final val Sealed = typeFlag(11, "sealed")
+  final val Sealed: FlagSet = typeFlag(11, "sealed")
 
-  final val AccessorOrSealed = Accessor.toCommonFlags
+  final val AccessorOrSealed: FlagSet = Accessor.toCommonFlags
 
  /** A mutable var */
-  final val Mutable = termFlag(12, "mutable")
+  final val Mutable: FlagSet = termFlag(12, "mutable")
 
   /** Symbol is local to current class (i.e. private[this] or protected[this]
    *  pre: Private or Protected are also set
    */
-  final val Local = commonFlag(13, "<local>")
+  final val Local: FlagSet = commonFlag(13, "<local>")
 
   /** A field generated for a primary constructor parameter (no matter if it's a 'val' or not),
    *  or an accessor of such a field.
    */
-  final val ParamAccessor = termFlag(14, "<paramaccessor>")
+  final val ParamAccessor: FlagSet = termFlag(14, "<paramaccessor>")
 
     /** A value or class implementing a module */
-  final val Module = commonFlag(15, "module")
-  final val ModuleVal = Module.toTermFlags
-  final val ModuleClass = Module.toTypeFlags
+  final val Module: FlagSet = commonFlag(15, "module")
+  final val ModuleVal: FlagSet = Module.toTermFlags
+  final val ModuleClass: FlagSet = Module.toTypeFlags
 
    /** A value or class representing a package */
-  final val Package = commonFlag(16, "<package>")
-  final val PackageVal = Package.toTermFlags
-  final val PackageClass = Package.toTypeFlags
+  final val Package: FlagSet = commonFlag(16, "<package>")
+  final val PackageVal: FlagSet = Package.toTermFlags
+  final val PackageClass: FlagSet = Package.toTypeFlags
 
   /** A case class or its companion object */
-  final val Case = commonFlag(17, "case")
-  final val CaseClass = Case.toTypeFlags
-  final val CaseVal = Case.toTermFlags
+  final val Case: FlagSet = commonFlag(17, "case")
+  final val CaseClass: FlagSet = Case.toTypeFlags
+  final val CaseVal: FlagSet = Case.toTermFlags
 
   /** A compiler-generated symbol, which is visible for type-checking
    *  (compare with artifact)
    */
-  final val Synthetic = commonFlag(18, "<synthetic>")
+  final val Synthetic: FlagSet = commonFlag(18, "<synthetic>")
 
   /** Labelled with `inline` modifier */
-  final val Inline = commonFlag(19, "inline")
+  final val Inline: FlagSet = commonFlag(19, "inline")
 
   /** A covariant type variable / an outer accessor */
-  final val CovariantOrOuter = commonFlag(20, "")
-  final val Covariant = typeFlag(20, "<covariant>")
-  final val OuterAccessor = termFlag(20, "<outer accessor>")
+  final val CovariantOrOuter: FlagSet = commonFlag(20, "")
+  final val Covariant: FlagSet = typeFlag(20, "<covariant>")
+  final val OuterAccessor: FlagSet = termFlag(20, "<outer accessor>")
 
   /** A contravariant type variable / a label method */
-  final val ContravariantOrLabel = commonFlag(21, "")
-  final val Contravariant = typeFlag(21, "<contravariant>")
-  final val Label = termFlag(21, "<label>")
+  final val ContravariantOrLabel: FlagSet = commonFlag(21, "")
+  final val Contravariant: FlagSet = typeFlag(21, "<contravariant>")
+  final val Label: FlagSet = termFlag(21, "<label>")
 
 
   /** A trait that has only abstract methods as members
    *  and therefore can be represented by a Java interface.
    *  Warning: flag is set during regular typer pass, should be tested only after typer.
    */
-  final val PureInterface = typeFlag(22, "interface")
+  final val PureInterface: FlagSet = typeFlag(22, "interface")
 
   /** Labeled with of abstract & override */
-  final val AbsOverride = termFlag(22, "abstract override")
+  final val AbsOverride: FlagSet = termFlag(22, "abstract override")
 
   /** Labeled with `abstract` modifier (an abstract class)
    *  Note: You should never see Abstract on any symbol except a class.
    *  Note: the flag counts as common, because it can be combined with OVERRIDE in a term.
    */
-  final val Abstract = commonFlag(23, "abstract")
+  final val Abstract: FlagSet = commonFlag(23, "abstract")
 
   /** Lazy val or method is known or assumed to be stable and realizable */
-  final val Stable = termFlag(24, "<stable>")
+  final val Stable: FlagSet = termFlag(24, "<stable>")
 
   /** A case parameter accessor */
-  final val CaseAccessor = termFlag(25, "<caseaccessor>")
+  final val CaseAccessor: FlagSet = termFlag(25, "<caseaccessor>")
 
   /** A super accessor */
-  final val Scala2SuperAccessor = termFlag(26, "<superaccessor>")
+  final val Scala2SuperAccessor: FlagSet = termFlag(26, "<superaccessor>")
 
   /** An unpickled Scala 2.x class */
-  final val Scala2x = typeFlag(26, "<scala-2.x>")
+  final val Scala2x: FlagSet = typeFlag(26, "<scala-2.x>")
 
-  final val SuperAccessorOrScala2x = Scala2x.toCommonFlags
+  final val SuperAccessorOrScala2x: FlagSet = Scala2x.toCommonFlags
 
   /** A method that has default params */
-  final val DefaultParameterized = termFlag(27, "<defaultparam>")
+  final val DefaultParameterized: FlagSet = termFlag(27, "<defaultparam>")
 
   /** Symbol is defined by a Java class */
-  final val JavaDefined = commonFlag(30, "<java>")
+  final val JavaDefined: FlagSet = commonFlag(30, "<java>")
 
   /** Symbol is implemented as a Java static */
-  final val JavaStatic = commonFlag(31, "<static>")
-  final val JavaStaticTerm = JavaStatic.toTermFlags
-  final val JavaStaticType = JavaStatic.toTypeFlags
+  final val JavaStatic: FlagSet = commonFlag(31, "<static>")
+  final val JavaStaticTerm: FlagSet = JavaStatic.toTermFlags
+  final val JavaStaticType: FlagSet = JavaStatic.toTypeFlags
 
   /** Trait does not have fields or initialization code.
    *  Warning: flag is set during regular typer pass, should be tested only after typer.
    */
-  final val NoInits = typeFlag(32, "<noInits>")
+  final val NoInits: FlagSet = typeFlag(32, "<noInits>")
 
   /** Variable is accessed from nested function. */
-  final val Captured = termFlag(32, "<captured>")
+  final val Captured: FlagSet = termFlag(32, "<captured>")
 
   /** Symbol should be ignored when typechecking; will be marked ACC_SYNTHETIC in bytecode */
-  final val Artifact = commonFlag(33, "<artifact>")
+  final val Artifact: FlagSet = commonFlag(33, "<artifact>")
 
   /** A bridge method. Set by Erasure */
-  final val Bridge = termFlag(34, "<bridge>")
+  final val Bridge: FlagSet = termFlag(34, "<bridge>")
 
   /** A proxy for an argument to an inline method */
-  final val InlineProxy = termFlag(35, "<inline proxy>")
+  final val InlineProxy: FlagSet = termFlag(35, "<inline proxy>")
 
   /** Symbol is a method which should be marked ACC_SYNCHRONIZED */
-  final val Synchronized = termFlag(36, "<synchronized>")
+  final val Synchronized: FlagSet = termFlag(36, "<synchronized>")
 
   /** Symbol is a Java-style varargs method */
-  final val JavaVarargs = termFlag(37, "<varargs>")
+  final val JavaVarargs: FlagSet = termFlag(37, "<varargs>")
 
   /** Symbol is a Java default method */
-  final val DefaultMethod = termFlag(38, "<defaultmethod>")
+  final val DefaultMethod: FlagSet = termFlag(38, "<defaultmethod>")
 
   /** Symbol is an enum class or enum case (if used with case) */
-  final val Enum = commonFlag(40, "<enum>")
+  final val Enum: FlagSet = commonFlag(40, "<enum>")
 
   /** Labeled with `erased` modifier (erased value)  */
-  final val Erased = termFlag(42, "erased")
+  final val Erased: FlagSet = termFlag(42, "erased")
 
   // Flags following this one are not pickled
 
   /** Symbol is not a member of its owner */
-  final val NonMember = commonFlag(45, "<non-member>")
+  final val NonMember: FlagSet = commonFlag(45, "<non-member>")
 
   /** Denotation is in train of being loaded and completed, used to catch cyclic dependencies */
-  final val Touched = commonFlag(48, "<touched>")
+  final val Touched: FlagSet = commonFlag(48, "<touched>")
 
   /** Class has been lifted out to package level, local value has been lifted out to class level */
-  final val Lifted = commonFlag(51, "<lifted>")
+  final val Lifted: FlagSet = commonFlag(51, "<lifted>")
 
   /** Term member has been mixed in */
-  final val MixedIn = commonFlag(52, "<mixedin>")
+  final val MixedIn: FlagSet = commonFlag(52, "<mixedin>")
 
   /** Symbol is a generated specialized member */
-  final val Specialized = commonFlag(53, "<specialized>")
+  final val Specialized: FlagSet = commonFlag(53, "<specialized>")
 
   /** Symbol is a self name */
-  final val SelfName = termFlag(54, "<selfname>")
+  final val SelfName: FlagSet = termFlag(54, "<selfname>")
 
   /** Symbol is an implementation class of a Scala2 trait */
-  final val ImplClass = typeFlag(54, "<implclass>")
+  final val ImplClass: FlagSet = typeFlag(54, "<implclass>")
 
-  final val SelfNameOrImplClass = SelfName.toCommonFlags
+  final val SelfNameOrImplClass: FlagSet = SelfName.toCommonFlags
 
   /** An existentially bound symbol (Scala 2.x only) */
-  final val Scala2ExistentialCommon = commonFlag(55, "<existential>")
-  final val Scala2Existential = Scala2ExistentialCommon.toTypeFlags
+  final val Scala2ExistentialCommon: FlagSet = commonFlag(55, "<existential>")
+  final val Scala2Existential: FlagSet = Scala2ExistentialCommon.toTypeFlags
 
   /** A module variable (Scala 2.x only) */
-  final val Scala2ModuleVar = termFlag(57, "<modulevar>")
+  final val Scala2ModuleVar: FlagSet = termFlag(57, "<modulevar>")
 
   /** A Scala 2.12 trait that has been augmented with static members */
-  final val Scala_2_12_Augmented = typeFlag(57, "<scala_2_12_augmented>")
+  final val Scala_2_12_Augmented: FlagSet = typeFlag(57, "<scala_2_12_augmented>")
 
   /** A definition that's initialized before the super call (Scala 2.x only) */
-  final val Scala2PreSuper = termFlag(58, "<presuper>")
+  final val Scala2PreSuper: FlagSet = termFlag(58, "<presuper>")
 
   /** A Scala 2.12 or higher trait */
-  final val Scala_2_12_Trait = typeFlag(58, "<scala_2_12_trait>")
+  final val Scala_2_12_Trait: FlagSet = typeFlag(58, "<scala_2_12_trait>")
 
   /** A macro */
-  final val Macro = commonFlag(59, "<macro>")
+  final val Macro: FlagSet = commonFlag(59, "<macro>")
 
   /** A method that is known to have inherited default parameters */
-  final val InheritedDefaultParams = termFlag(60, "<inherited-default-param>")
+  final val InheritedDefaultParams: FlagSet = termFlag(60, "<inherited-default-param>")
 
   /** Translation of Scala2's EXPANDEDNAME flag. This flag is never stored in
    *  symbols, is only used locally when reading the flags of a Scala2 symbol.
    *  It's therefore safe to share the code with `InheritedDefaultParams` because
    *  the latter is never present in Scala2 unpickle info.
    */
-  final val Scala2ExpandedName = InheritedDefaultParams.toCommonFlags
+  final val Scala2ExpandedName: FlagSet = InheritedDefaultParams.toCommonFlags
 
   /** A method that is known to have no default parameters */
-  final val NoDefaultParams = termFlag(61, "<no-default-param>")
+  final val NoDefaultParams: FlagSet = termFlag(61, "<no-default-param>")
 
   /** A type symbol with provisional empty bounds */
-  final val Provisional = typeFlag(61, "<provisional>")
+  final val Provisional: FlagSet = typeFlag(61, "<provisional>")
 
   /** A denotation that is valid in all run-ids */
-  final val Permanent = commonFlag(62, "<permanent>")
+  final val Permanent: FlagSet = commonFlag(62, "<permanent>")
 
 // --------- Combined Flag Sets and Conjunctions ----------------------
 
   /** Flags representing source modifiers */
-  final val SourceModifierFlags =
+  final val SourceModifierFlags: FlagSet =
     commonFlags(Private, Protected, Abstract, Final, Inline,
      Sealed, Case, Implicit, Override, AbsOverride, Lazy, JavaStatic, Erased)
 
   /** Flags representing modifiers that can appear in trees */
-  final val ModifierFlags =
+  final val ModifierFlags: FlagSet =
     SourceModifierFlags | Module | Param | Synthetic | Package | Local |
     commonFlags(Mutable)
       // | Trait is subsumed by commonFlags(Lazy) from SourceModifierFlags
@@ -448,10 +448,10 @@ object Flags {
   assert(ModifierFlags.isTermFlags && ModifierFlags.isTypeFlags)
 
   /** Flags representing access rights */
-  final val AccessFlags = Private | Protected | Local
+  final val AccessFlags: FlagSet = Private | Protected | Local
 
   /** Flags that are not (re)set when completing the denotation */
-  final val FromStartFlags =
+  final val FromStartFlags: FlagSet =
     Module | Package | Deferred | Method.toCommonFlags |
     HigherKinded.toCommonFlags | Param | ParamAccessor.toCommonFlags |
     Scala2ExistentialCommon | Mutable.toCommonFlags | Touched | JavaStatic |
@@ -464,7 +464,7 @@ object Flags {
    *  file defining the symbol is loaded (which is generally before the denotation
    *  is completed)
    */
-  final val AfterLoadFlags =
+  final val AfterLoadFlags: FlagSet =
     FromStartFlags | AccessFlags | Final | AccessorOrSealed | LazyOrTrait | SelfNameOrImplClass
 
   assert(FromStartFlags.isTermFlags && FromStartFlags.isTypeFlags)
@@ -472,34 +472,34 @@ object Flags {
   assert(AfterLoadFlags.isTermFlags && AfterLoadFlags.isTypeFlags)
 
   /** A value that's unstable unless complemented with a Stable flag */
-  final val UnstableValue = Mutable | Method
+  final val UnstableValue: FlagSet = Mutable | Method
 
   /** Flags that express the variance of a type parameter. */
-  final val VarianceFlags = Covariant | Contravariant
+  final val VarianceFlags: FlagSet = Covariant | Contravariant
 
   /** Flags that are passed from a type parameter of a class to a refinement symbol
     * that sets the type parameter */
-  final val RetainedTypeArgFlags = VarianceFlags | Protected | Local
+  final val RetainedTypeArgFlags: FlagSet = VarianceFlags | Protected | Local
 
   /** Modules always have these flags set */
-  final val ModuleValCreationFlags = ModuleVal | Lazy | Final | Stable
+  final val ModuleValCreationFlags: FlagSet = ModuleVal | Lazy | Final | Stable
 
   /** Module classes always have these flags set */
-  final val ModuleClassCreationFlags = ModuleClass | Final
+  final val ModuleClassCreationFlags: FlagSet = ModuleClass | Final
 
   /** Accessors always have these flags set */
-  final val AccessorCreationFlags = Method | Accessor
+  final val AccessorCreationFlags: FlagSet = Method | Accessor
 
   /** Pure interfaces always have these flags */
-  final val PureInterfaceCreationFlags = Trait | NoInits | PureInterface
+  final val PureInterfaceCreationFlags: FlagSet = Trait | NoInits | PureInterface
 
-  final val NoInitsInterface = NoInits | PureInterface
+  final val NoInitsInterface: FlagSet = NoInits | PureInterface
 
   /** The flags of the self symbol */
-  final val SelfSymFlags = Private | Local | Deferred
+  final val SelfSymFlags: FlagSet = Private | Local | Deferred
 
   /** The flags of a class type parameter */
-  final val ClassTypeParamCreationFlags =
+  final val ClassTypeParamCreationFlags: FlagSet =
     TypeParam | Deferred | Private | Local
 
   /** Flags that can apply to both a module val and a module class, except those that
@@ -519,164 +519,164 @@ object Flags {
   final val RetainedModuleClassFlags: FlagSet = RetainedModuleValAndClassFlags | ImplClass | Enum
 
   /** Packages and package classes always have these flags set */
-  final val PackageCreationFlags =
+  final val PackageCreationFlags: FlagSet =
     Module | Package | Final | JavaDefined
 
   /** These flags are pickled */
-  final val PickledFlags = flagRange(FirstFlag, FirstNotPickledFlag)
+  final val PickledFlags: FlagSet = flagRange(FirstFlag, FirstNotPickledFlag)
 
-  final val AnyFlags = flagRange(FirstFlag, MaxFlag)
+  final val AnyFlags: FlagSet = flagRange(FirstFlag, MaxFlag)
 
   /** An abstract class or a trait */
-  final val AbstractOrTrait = Abstract | Trait
+  final val AbstractOrTrait: FlagSet = Abstract | Trait
 
   /** Labeled `private` or `protected[local]` */
-  final val PrivateOrLocal = Private | Local
+  final val PrivateOrLocal: FlagSet = Private | Local
 
   /** Either a module or a final class */
-  final val ModuleOrFinal = ModuleClass | Final
+  final val ModuleOrFinal: FlagSet = ModuleClass | Final
 
   /** Either mutable or lazy */
-  final val MutableOrLazy = Mutable | Lazy
+  final val MutableOrLazy: FlagSet = Mutable | Lazy
 
   /** Either method or lazy */
-  final val MethodOrLazy = Method | Lazy
+  final val MethodOrLazy: FlagSet = Method | Lazy
 
   /** Either method or module */
-  final val MethodOrModule = Method | Module
+  final val MethodOrModule: FlagSet = Method | Module
 
   /** Either method or lazy or deferred */
-  final val MethodOrLazyOrDeferred = Method | Lazy | Deferred
+  final val MethodOrLazyOrDeferred: FlagSet = Method | Lazy | Deferred
 
   /** An inline method or inline argument proxy */
-  final val InlineOrProxy = Inline | InlineProxy
+  final val InlineOrProxy: FlagSet = Inline | InlineProxy
 
   /** Assumed to be pure */
-  final val StableOrErased = Stable | Erased
+  final val StableOrErased: FlagSet = Stable | Erased
 
   /** Labeled `private`, `final`, or `inline` */
-  final val EffectivelyFinal = Private | Final | Inline
+  final val EffectivelyFinal: FlagSet = Private | Final | Inline
 
   /** A private method */
-  final val PrivateMethod = allOf(Private, Method)
+  final val PrivateMethod: FlagConjunction = allOf(Private, Method)
 
   /** A private accessor */
-  final val PrivateAccessor = allOf(Private, Accessor)
+  final val PrivateAccessor: FlagConjunction = allOf(Private, Accessor)
 
   /** An inline method */
-  final val InlineMethod = allOf(Inline, Method)
+  final val InlineMethod: FlagConjunction = allOf(Inline, Method)
 
   /** An implicit inline method */
-  final val ImplicitInlineMethod = allOf(Inline, Implicit, Method)
+  final val ImplicitInlineMethod: FlagConjunction = allOf(Inline, Implicit, Method)
 
   /** An inline parameter */
-  final val InlineParam = allOf(Inline, Param)
+  final val InlineParam: FlagConjunction = allOf(Inline, Param)
 
   /** An enum case */
-  final val EnumCase = allOf(Enum, Case)
+  final val EnumCase: FlagConjunction = allOf(Enum, Case)
 
   /** A term parameter or parameter accessor */
-  final val TermParamOrAccessor = Param | ParamAccessor
+  final val TermParamOrAccessor: FlagSet = Param | ParamAccessor
 
   /** A lazy or deferred value */
-  final val LazyOrDeferred = Lazy | Deferred
+  final val LazyOrDeferred: FlagSet = Lazy | Deferred
 
   /** An accessor or label */
-  final val AccessorOrLabel = Accessor | Label
+  final val AccessorOrLabel: FlagSet = Accessor | Label
 
   /** An accessor or a synthetic symbol */
-  final val AccessorOrSynthetic = Accessor | Synthetic
+  final val AccessorOrSynthetic: FlagSet = Accessor | Synthetic
 
   /** A synthetic or private definition */
-  final val SyntheticOrPrivate = Synthetic | Private
+  final val SyntheticOrPrivate: FlagSet = Synthetic | Private
 
   /** A deferred term member or a parameter or parameter accessor (these don't have right hand sides) */
-  final val DeferredOrTermParamOrAccessor = Deferred | TermParam | ParamAccessor
+  final val DeferredOrTermParamOrAccessor: FlagSet = Deferred | TermParam | ParamAccessor
 
   /** A deferred type member or parameter (these don't have right hand sides) */
-  final val DeferredOrTypeParam = Deferred | TypeParam
+  final val DeferredOrTypeParam: FlagSet = Deferred | TypeParam
 
   /** value that's final or inline */
-  final val FinalOrInline = Final | Inline
+  final val FinalOrInline: FlagSet = Final | Inline
 
   /** A covariant type parameter instance */
-  final val LocalCovariant = allOf(Local, Covariant)
+  final val LocalCovariant: FlagConjunction = allOf(Local, Covariant)
 
   /** A contravariant type parameter instance */
-  final val LocalContravariant = allOf(Local, Contravariant)
+  final val LocalContravariant: FlagConjunction = allOf(Local, Contravariant)
 
   /** Has defined or inherited default parameters */
-  final val HasDefaultParams = DefaultParameterized | InheritedDefaultParams
+  final val HasDefaultParams: FlagSet = DefaultParameterized | InheritedDefaultParams
 
   /** Is valid forever */
-  final val ValidForever = Package | Permanent | Scala2ExistentialCommon
+  final val ValidForever: FlagSet = Package | Permanent | Scala2ExistentialCommon
 
   /** A type parameter of a class or trait */
-  final val ClassTypeParam = allOf(TypeParam, Private)
+  final val ClassTypeParam: FlagConjunction = allOf(TypeParam, Private)
 
   /** Is a default parameter in Scala 2*/
-  final val DefaultParameter = allOf(Param, DefaultParameterized)
+  final val DefaultParameter: FlagConjunction = allOf(Param, DefaultParameterized)
 
   /** A Scala 2 Macro */
-  final val Scala2Macro = allOf(Macro, Scala2x)
+  final val Scala2Macro: FlagConjunction = allOf(Macro, Scala2x)
 
   /** A trait that does not need to be initialized */
-  final val NoInitsTrait = allOf(Trait, NoInits)
+  final val NoInitsTrait: FlagConjunction = allOf(Trait, NoInits)
 
   /** A Java interface, potentially with default methods */
-  final val JavaTrait = allOf(JavaDefined, Trait, NoInits)
+  final val JavaTrait: FlagConjunction = allOf(JavaDefined, Trait, NoInits)
 
     /** A Java interface */ // TODO when unpickling, reconstitute from context
-  final val JavaInterface = allOf(JavaDefined, Trait)
+  final val JavaInterface: FlagConjunction = allOf(JavaDefined, Trait)
 
   /** A Java companion object */
-  final val JavaModule = allOf(JavaDefined, Module)
+  final val JavaModule: FlagConjunction = allOf(JavaDefined, Module)
 
   /** A Java companion object */
-  final val JavaProtected = allOf(JavaDefined, Protected)
+  final val JavaProtected: FlagConjunction = allOf(JavaDefined, Protected)
 
   /** A Java enum */
-  final val JavaEnum = allOf(JavaDefined, Enum)
+  final val JavaEnum: FlagConjunction = allOf(JavaDefined, Enum)
 
   /** A Java enum trait */
-  final val JavaEnumTrait = allOf(JavaDefined, Enum)
+  final val JavaEnumTrait: FlagConjunction = allOf(JavaDefined, Enum)
 
   /** A Java enum value */
-  final val JavaEnumValue = allOf(Stable, JavaStatic, JavaDefined, Enum)
+  final val JavaEnumValue: FlagConjunction = allOf(Stable, JavaStatic, JavaDefined, Enum)
 
   /** Labeled private[this] */
-  final val PrivateLocal = allOf(Private, Local)
+  final val PrivateLocal: FlagConjunction = allOf(Private, Local)
 
   /** A private[this] parameter accessor */
-  final val PrivateLocalParamAccessor = allOf(Private, Local, ParamAccessor)
+  final val PrivateLocalParamAccessor: FlagConjunction = allOf(Private, Local, ParamAccessor)
 
   /** A parameter forwarder */
-  final val ParamForwarder = allOf(Method, Stable, ParamAccessor)
+  final val ParamForwarder: FlagConjunction = allOf(Method, Stable, ParamAccessor)
 
   /** A private[this] parameter */
-  final val PrivateLocalParam = allOf(Private, Local, Param)
+  final val PrivateLocalParam: FlagConjunction = allOf(Private, Local, Param)
 
   /** A private parameter accessor */
-  final val PrivateParamAccessor = allOf(Private, ParamAccessor)
+  final val PrivateParamAccessor: FlagConjunction = allOf(Private, ParamAccessor)
 
   /** A local parameter */
-  final val ParamAndLocal = allOf(Param, Local)
+  final val ParamAndLocal: FlagConjunction = allOf(Param, Local)
 
   /** Labeled protected[this] */
-  final val ProtectedLocal = allOf(Protected, Local)
+  final val ProtectedLocal: FlagConjunction = 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)
+  final val StaticProtected: FlagConjunction = allOf(JavaDefined, Protected, JavaStatic)
+
+  final val AbstractFinal: FlagConjunction = allOf(Abstract, Final)
+  final val AbstractSealed: FlagConjunction = allOf(Abstract, Sealed)
+  final val SyntheticArtifact: FlagConjunction = allOf(Synthetic, Artifact)
+  final val SyntheticModule: FlagConjunction = allOf(Synthetic, Module)
+  final val SyntheticTermParam: FlagConjunction = allOf(Synthetic, TermParam)
+  final val SyntheticTypeParam: FlagConjunction = allOf(Synthetic, TypeParam)
+  final val SyntheticCase: FlagConjunction = allOf(Synthetic, Case)
+  final val AbstractAndOverride: FlagConjunction = allOf(Abstract, Override)
+  final val Scala2Trait: FlagConjunction = allOf(Scala2x, Trait)
 
   implicit def conjToFlagSet(conj: FlagConjunction): FlagSet =
     FlagSet(conj.bits)
diff --git a/compiler/src/dotty/tools/dotc/core/Hashable.scala b/compiler/src/dotty/tools/dotc/core/Hashable.scala
index 83c04b9d47e8..d554aaecbb58 100644
--- a/compiler/src/dotty/tools/dotc/core/Hashable.scala
+++ b/compiler/src/dotty/tools/dotc/core/Hashable.scala
@@ -43,10 +43,10 @@ trait Hashable {
   protected final def finishHash(hashCode: Int, arity: Int): Int =
     avoidSpecialHashes(hashing.finalizeHash(hashCode, arity))
 
-  final def typeHash(bs: Binders, tp: Type) =
+  final def typeHash(bs: Binders, tp: Type): Int =
     if (bs == null || tp.stableHash) tp.hash else tp.computeHash(bs)
 
-  def identityHash(bs: Binders) = avoidSpecialHashes(System.identityHashCode(this))
+  def identityHash(bs: Binders): Int = avoidSpecialHashes(System.identityHashCode(this))
 
   protected def finishHash(bs: Binders, seed: Int, arity: Int, tp: Type): Int = {
     val elemHash = typeHash(bs, tp)
@@ -105,11 +105,11 @@ trait Hashable {
   protected final def doHash(x1: Int, x2: Int): Int =
     finishHash(hashing.mix(hashing.mix(hashSeed, x1), x2), 1)
 
-  protected final def addDelta(elemHash: Int, delta: Int) =
+  protected final def addDelta(elemHash: Int, delta: Int): Int =
     if (elemHash == NotCached) NotCached
     else avoidSpecialHashes(elemHash + delta)
 
-  protected def avoidSpecialHashes(h: Int) =
+  protected def avoidSpecialHashes(h: Int): Int =
     if (h == NotCached) NotCachedAlt
     else if (h == HashUnknown) HashUnknownAlt
     else h
diff --git a/compiler/src/dotty/tools/dotc/core/Mode.scala b/compiler/src/dotty/tools/dotc/core/Mode.scala
index a867b828cb7e..fa41c4bc3573 100644
--- a/compiler/src/dotty/tools/dotc/core/Mode.scala
+++ b/compiler/src/dotty/tools/dotc/core/Mode.scala
@@ -3,19 +3,19 @@ package dotty.tools.dotc.core
 /** A collection of mode bits that are part of a context */
 case class Mode(val bits: Int) extends AnyVal {
   import Mode._
-  def | (that: Mode) = Mode(bits | that.bits)
-  def & (that: Mode) = Mode(bits & that.bits)
-  def &~ (that: Mode) = Mode(bits & ~that.bits)
-  def is (that: Mode) = (bits & that.bits) == that.bits
+  def | (that: Mode): Mode = Mode(bits | that.bits)
+  def & (that: Mode): Mode = Mode(bits & that.bits)
+  def &~ (that: Mode): Mode = Mode(bits & ~that.bits)
+  def is (that: Mode): Boolean = (bits & that.bits) == that.bits
 
-  def isExpr = (this & PatternOrTypeBits) == None
+  def isExpr: Boolean = (this & PatternOrTypeBits) == None
 
-  override def toString =
+  override def toString: String =
     (0 until 31).filter(i => (bits & (1 << i)) != 0).map(modeName).mkString("Mode(", ",", ")")
 }
 
 object Mode {
-  val None = Mode(0)
+  val None: Mode = Mode(0)
 
   private val modeName = new Array[String](32)
 
@@ -24,11 +24,11 @@ object Mode {
     Mode(1 << bit)
   }
 
-  val Pattern = newMode(0, "Pattern")
-  val Type = newMode(1, "Type")
+  val Pattern: Mode = newMode(0, "Pattern")
+  val Type: Mode = newMode(1, "Type")
 
-  val ImplicitsEnabled = newMode(2, "ImplicitsEnabled")
-  val InferringReturnType = newMode(3, "InferringReturnType")
+  val ImplicitsEnabled: Mode = newMode(2, "ImplicitsEnabled")
+  val InferringReturnType: Mode = newMode(3, "InferringReturnType")
 
   /** This mode bit is set if we collect information without reference to a valid
    *  context with typerstate and constraint. This is typically done when we
@@ -36,68 +36,68 @@ object Mode {
    *  Therefore, if TypevarsMissContext is set, subtyping becomes looser, and assumes
    *  that TypeParamRefs can be sub- and supertypes of anything. See TypeComparer.
    */
-  val TypevarsMissContext = newMode(4, "TypevarsMissContext")
+  val TypevarsMissContext: Mode = newMode(4, "TypevarsMissContext")
 
-  val CheckCyclic = newMode(5, "CheckCyclic")
+  val CheckCyclic: Mode = newMode(5, "CheckCyclic")
 
   /** We are looking at the arguments of a supercall */
-  val InSuperCall = newMode(6, "InSuperCall")
+  val InSuperCall: Mode = newMode(6, "InSuperCall")
 
   /** We are in a pattern alternative */
-  val InPatternAlternative = newMode(7, "InPatternAlternative")
+  val InPatternAlternative: Mode = newMode(7, "InPatternAlternative")
 
   /** Allow GADTFlexType labelled types to have their bounds adjusted */
-  val GADTflexible = newMode(8, "GADTflexible")
+  val GADTflexible: Mode = newMode(8, "GADTflexible")
 
   /** We are currently printing something: avoid to produce more logs about
    *  the printing
    */
-  val Printing = newMode(10, "Printing")
+  val Printing: Mode = newMode(10, "Printing")
 
   /** We are currently typechecking an ident to determine whether some implicit
    *  is shadowed - don't do any other shadowing tests.
    */
-  val ImplicitShadowing = newMode(11, "ImplicitShadowing")
+  val ImplicitShadowing: Mode = newMode(11, "ImplicitShadowing")
 
   /** We are currently in a `viewExists` check. In that case, ambiguous
    *  implicits checks are disabled and we succeed with the first implicit
    *  found.
    */
-  val ImplicitExploration = newMode(12, "ImplicitExploration")
+  val ImplicitExploration: Mode = newMode(12, "ImplicitExploration")
 
   /** We are currently unpickling Scala2 info */
-  val Scala2Unpickling = newMode(13, "Scala2Unpickling")
+  val Scala2Unpickling: Mode = newMode(13, "Scala2Unpickling")
 
   /** We are currently unpickling from Java 8 or higher */
-  val Java8Unpickling = newMode(14, "Java8Unpickling")
+  val Java8Unpickling: Mode = newMode(14, "Java8Unpickling")
 
   /** Use Scala2 scheme for overloading and implicit resolution */
-  val OldOverloadingResolution = newMode(15, "OldOverloadingResolution")
+  val OldOverloadingResolution: Mode = newMode(15, "OldOverloadingResolution")
 
   /** Allow hk applications of type lambdas to wildcard arguments;
    *  used for checking that such applications do not normally arise
    */
-  val AllowLambdaWildcardApply = newMode(16, "AllowHKApplyToWildcards")
+  val AllowLambdaWildcardApply: Mode = newMode(16, "AllowHKApplyToWildcards")
 
   /** Read original positions when unpickling from TASTY */
-  val ReadPositions = newMode(17, "ReadPositions")
+  val ReadPositions: Mode = newMode(17, "ReadPositions")
 
   /** Don't suppress exceptions thrown during show */
-  val PrintShowExceptions = newMode(18, "PrintShowExceptions")
+  val PrintShowExceptions: Mode = newMode(18, "PrintShowExceptions")
 
-  val PatternOrTypeBits = Pattern | Type | InPatternAlternative
+  val PatternOrTypeBits: Mode = Pattern | Type | InPatternAlternative
 
   /** We are elaborating the fully qualified name of a package clause.
    *  In this case, identifiers should never be imported.
    */
-  val InPackageClauseName = newMode(19, "InPackageClauseName")
+  val InPackageClauseName: Mode = newMode(19, "InPackageClauseName")
 
   /** We are in the IDE */
-  val Interactive = newMode(20, "Interactive")
+  val Interactive: Mode = newMode(20, "Interactive")
 
   /** We are typing the body of an inline method */
-  val InlineableBody = newMode(21, "InlineableBody")
+  val InlineableBody: Mode = newMode(21, "InlineableBody")
 
   /** Read comments from definitions when unpickling from TASTY */
-  val ReadComments = newMode(22, "ReadComments")
+  val ReadComments: Mode = newMode(22, "ReadComments")
 }
diff --git a/compiler/src/dotty/tools/dotc/core/NameKinds.scala b/compiler/src/dotty/tools/dotc/core/NameKinds.scala
index 1d38aeb88f97..508479c8dbff 100644
--- a/compiler/src/dotty/tools/dotc/core/NameKinds.scala
+++ b/compiler/src/dotty/tools/dotc/core/NameKinds.scala
@@ -5,9 +5,7 @@ package core
 import Names._
 import NameOps._
 import StdNames._
-import util.DotClass
 import NameTags._
-import Decorators._
 import Contexts.Context
 import collection.mutable
 
@@ -39,16 +37,16 @@ object NameKinds {
 
     /** A simple info type; some subclasses of Kind define more refined versions */
     class Info extends NameInfo { this: ThisInfo =>
-      def kind = self
-      def mkString(underlying: TermName) = self.mkString(underlying, this)
-      override def toString = infoString
+      def kind: NameKind = self
+      def mkString(underlying: TermName): String = self.mkString(underlying, this)
+      override def toString: String = infoString
     }
 
     /** Does this kind define logically a new name (respectively qualified name)?
      *  Tested by the `replace` and `collect` combinators of class `Name`.
      */
-    def definesNewName = false
-    def definesQualifiedName = false
+    def definesNewName: Boolean = false
+    def definesQualifiedName: Boolean = false
 
     /** Unmangle simple name `name` into a name of this kind, or return
      *  original name if this is not possible.
@@ -67,19 +65,19 @@ object NameKinds {
 
   object SimpleNameKind extends NameKind(UTF8) { self =>
     type ThisInfo = Info
-    val info = new Info
-    def mkString(underlying: TermName, info: ThisInfo) = unsupported("mkString")
-    def infoString = unsupported("infoString")
+    val info: Info = new Info
+    def mkString(underlying: TermName, info: ThisInfo): Nothing = unsupported("mkString")
+    def infoString: Nothing = unsupported("infoString")
   }
 
   /** The kind of names that add a simple classification to an underlying name.
    */
   abstract class ClassifiedNameKind(tag: Int, val infoString: String) extends NameKind(tag) {
     type ThisInfo = Info
-    val info = new Info
+    val info: Info = new Info
 
     /** Build a new name of this kind from an underlying name */
-    def apply(underlying: TermName) = underlying.derived(info)
+    def apply(underlying: TermName): TermName = underlying.derived(info)
 
     /** Extractor operation for names of this kind */
     def unapply(name: DerivedName): Option[TermName] =  name match {
@@ -93,7 +91,7 @@ object NameKinds {
   /** The kind of names that get formed by adding a prefix to an underlying name */
   class PrefixNameKind(tag: Int, prefix: String, optInfoString: String = "")
   extends ClassifiedNameKind(tag, if (optInfoString.isEmpty) s"Prefix $prefix" else optInfoString) {
-    def mkString(underlying: TermName, info: ThisInfo) =
+    def mkString(underlying: TermName, info: ThisInfo): String =
       underlying.qualToString(_.toString, n => prefix + n.toString)
     override def unmangle(name: SimpleName): TermName =
       if (name.startsWith(prefix)) apply(name.drop(prefix.length).asSimpleName)
@@ -103,7 +101,7 @@ object NameKinds {
   /** The kind of names that get formed by appending a suffix to an underlying name */
   class SuffixNameKind(tag: Int, suffix: String, optInfoString: String = "")
   extends ClassifiedNameKind(tag, if (optInfoString.isEmpty) s"Suffix $suffix" else optInfoString) {
-    def mkString(underlying: TermName, info: ThisInfo) =
+    def mkString(underlying: TermName, info: ThisInfo): String =
       underlying.qualToString(_.toString, n => n.toString + suffix)
     override def unmangle(name: SimpleName): TermName =
       if (name.endsWith(suffix)) apply(name.take(name.length - suffix.length).asSimpleName)
@@ -125,7 +123,7 @@ object NameKinds {
     type ThisInfo = QualInfo
     case class QualInfo(name: SimpleName) extends Info with QualifiedInfo {
       override def map(f: SimpleName => SimpleName): NameInfo = new QualInfo(f(name))
-      override def toString = s"$infoString $name"
+      override def toString: String = s"$infoString $name"
     }
 
     def apply(qual: TermName, name: SimpleName): TermName =
@@ -145,13 +143,13 @@ object NameKinds {
       case _ => None
     }
 
-    override def definesNewName = true
-    override def definesQualifiedName = true
+    override def definesNewName: Boolean = true
+    override def definesQualifiedName: Boolean = true
 
-    def mkString(underlying: TermName, info: ThisInfo) =
+    def mkString(underlying: TermName, info: ThisInfo): String =
       s"$underlying$separator${info.name}"
 
-    def infoString = s"Qualified $separator"
+    def infoString: String = s"Qualified $separator"
 
     qualifiedNameKinds(tag) = this
   }
@@ -174,9 +172,9 @@ object NameKinds {
   abstract class NumberedNameKind(tag: Int, val infoString: String) extends NameKind(tag) { self =>
     type ThisInfo = NumberedInfo
     case class NumberedInfo(val num: Int) extends Info with NameKinds.NumberedInfo {
-      override def toString = s"$infoString $num"
+      override def toString: String = s"$infoString $num"
     }
-    def apply(qual: TermName, num: Int) =
+    def apply(qual: TermName, num: Int): TermName =
       qual.derived(new NumberedInfo(num))
     def unapply(name: DerivedName): Option[(TermName, Int)] = name match {
       case DerivedName(underlying, info: this.NumberedInfo) => Some((underlying, info.num))
@@ -208,9 +206,9 @@ object NameKinds {
    */
   case class UniqueNameKind(val separator: String)
   extends NumberedNameKind(UNIQUE, s"Unique $separator") {
-    override def definesNewName = true
+    override def definesNewName: Boolean = true
 
-    def mkString(underlying: TermName, info: ThisInfo) = {
+    def mkString(underlying: TermName, info: ThisInfo): String = {
       val safePrefix = str.sanitize(underlying.toString) + separator
       safePrefix + info.num
     }
@@ -239,16 +237,16 @@ object NameKinds {
   }
 
   /** Names of the form `prefix . name` */
-  val QualifiedName = new QualifiedNameKind(QUALIFIED, ".")
+  val QualifiedName: QualifiedNameKind = new QualifiedNameKind(QUALIFIED, ".")
 
   /** Names of the form `prefix $ name` that are constructed as a result of flattening */
-  val FlatName = new QualifiedNameKind(FLATTENED, "$")
+  val FlatName: QualifiedNameKind = new QualifiedNameKind(FLATTENED, "$")
 
   /** Names of the form `prefix $ name` that are prefixes of expanded names */
-  val ExpandPrefixName = new QualifiedNameKind(EXPANDPREFIX, "$")
+  val ExpandPrefixName: QualifiedNameKind = new QualifiedNameKind(EXPANDPREFIX, "$")
 
   /** Expanded names of the form `prefix $$ name`. */
-  val ExpandedName = new QualifiedNameKind(EXPANDED, str.EXPAND_SEPARATOR) {
+  val ExpandedName: QualifiedNameKind = new QualifiedNameKind(EXPANDED, str.EXPAND_SEPARATOR) {
     private val FalseSuper = termName("$$super")
     private val FalseSuperLength = FalseSuper.length
 
@@ -268,39 +266,39 @@ object NameKinds {
   }
 
   /** Expanded names of the form `prefix $_setter_$ name`. These only occur in Scala2. */
-  val TraitSetterName = new QualifiedNameKind(TRAITSETTER, str.TRAIT_SETTER_SEPARATOR)
+  val TraitSetterName: QualifiedNameKind = new QualifiedNameKind(TRAITSETTER, str.TRAIT_SETTER_SEPARATOR)
 
   /** Unique names of the form `prefix $ n` or `$ n $` */
-  val UniqueName = new UniqueNameKind("$") {
+  val UniqueName: UniqueNameKind = new UniqueNameKind("$") {
     override def mkString(underlying: TermName, info: ThisInfo) =
       if (underlying.isEmpty) "$" + info.num + "$" else super.mkString(underlying, info)
   }
 
   /** Other unique names */
-  val TempResultName           = new UniqueNameKind("ev$")
-  val EvidenceParamName        = new UniqueNameKind("evidence$")
-  val DepParamName             = new UniqueNameKind("(param)")
-  val LazyImplicitName         = new UniqueNameKind("$_lazy_implicit_$")
-  val LazyLocalName            = new UniqueNameKind("$lzy")
-  val LazyLocalInitName        = new UniqueNameKind("$lzyINIT")
-  val LazyFieldOffsetName      = new UniqueNameKind("$OFFSET")
-  val LazyBitMapName           = new UniqueNameKind(nme.BITMAP_PREFIX.toString)
-  val NonLocalReturnKeyName    = new UniqueNameKind("nonLocalReturnKey")
-  val WildcardParamName        = new UniqueNameKind("_$")
-  val TailLabelName            = new UniqueNameKind("tailLabel")
-  val ExceptionBinderName      = new UniqueNameKind("ex")
-  val SkolemName               = new UniqueNameKind("?")
-  val LiftedTreeName           = new UniqueNameKind("liftedTree")
-  val SuperArgName             = new UniqueNameKind("$superArg$")
-  val DocArtifactName          = new UniqueNameKind("$doc")
-  val UniqueInlineName         = new UniqueNameKind("$i")
-  val InlineScrutineeName      = new UniqueNameKind("$scrutinee")
-  val InlineBinderName         = new UniqueNameKind("$elem")
+  val TempResultName: UniqueNameKind         = new UniqueNameKind("ev$")
+  val EvidenceParamName: UniqueNameKind      = new UniqueNameKind("evidence$")
+  val DepParamName: UniqueNameKind           = new UniqueNameKind("(param)")
+  val LazyImplicitName: UniqueNameKind       = new UniqueNameKind("$_lazy_implicit_$")
+  val LazyLocalName: UniqueNameKind          = new UniqueNameKind("$lzy")
+  val LazyLocalInitName: UniqueNameKind      = new UniqueNameKind("$lzyINIT")
+  val LazyFieldOffsetName: UniqueNameKind    = new UniqueNameKind("$OFFSET")
+  val LazyBitMapName: UniqueNameKind         = new UniqueNameKind(nme.BITMAP_PREFIX.toString)
+  val NonLocalReturnKeyName: UniqueNameKind  = new UniqueNameKind("nonLocalReturnKey")
+  val WildcardParamName: UniqueNameKind      = new UniqueNameKind("_$")
+  val TailLabelName: UniqueNameKind          = new UniqueNameKind("tailLabel")
+  val ExceptionBinderName: UniqueNameKind    = new UniqueNameKind("ex")
+  val SkolemName: UniqueNameKind             = new UniqueNameKind("?")
+  val LiftedTreeName: UniqueNameKind         = new UniqueNameKind("liftedTree")
+  val SuperArgName: UniqueNameKind           = new UniqueNameKind("$superArg$")
+  val DocArtifactName: UniqueNameKind        = new UniqueNameKind("$doc")
+  val UniqueInlineName: UniqueNameKind       = new UniqueNameKind("$i")
+  val InlineScrutineeName: UniqueNameKind    = new UniqueNameKind("$scrutinee")
+  val InlineBinderName: UniqueNameKind       = new UniqueNameKind("$elem")
 
   /** A kind of unique extension methods; Unlike other unique names, these can be
    *  unmangled.
    */
-  val UniqueExtMethName = new UniqueNameKind("$extension") {
+  val UniqueExtMethName: UniqueNameKind = new UniqueNameKind("$extension") {
     override def unmangle(name: SimpleName): TermName = {
       val i = skipSeparatorAndNum(name, separator)
       if (i > 0) {
@@ -313,14 +311,14 @@ object NameKinds {
   }
 
   /** Kinds of unique names generated by the pattern matcher */
-  val PatMatStdBinderName     = new UniqueNameKind("x")
-  val PatMatAltsName          = new UniqueNameKind("matchAlts")
-  val PatMatResultName        = new UniqueNameKind("matchResult")
+  val PatMatStdBinderName: UniqueNameKind    = new UniqueNameKind("x")
+  val PatMatAltsName: UniqueNameKind         = new UniqueNameKind("matchAlts")
+  val PatMatResultName: UniqueNameKind       = new UniqueNameKind("matchResult")
 
-  val LocalOptInlineLocalObj  = new UniqueNameKind("ilo")
+  val LocalOptInlineLocalObj: UniqueNameKind = new UniqueNameKind("ilo")
 
   /** The kind of names of default argument getters */
-  val DefaultGetterName = new NumberedNameKind(DEFAULTGETTER, "DefaultGetter") {
+  val DefaultGetterName: NumberedNameKind = new NumberedNameKind(DEFAULTGETTER, "DefaultGetter") {
     def mkString(underlying: TermName, info: ThisInfo) = {
       val prefix = if (underlying.isConstructorName) nme.DEFAULT_GETTER_INIT else underlying
       prefix.toString + str.DEFAULT_GETTER + (info.num + 1)
@@ -339,45 +337,45 @@ object NameKinds {
   }
 
   /** The kind of names that also encode a variance: 0 for contravariance, 1 for covariance. */
-  val VariantName = new NumberedNameKind(VARIANT, "Variant") {
+  val VariantName: NumberedNameKind = new NumberedNameKind(VARIANT, "Variant") {
     def mkString(underlying: TermName, info: ThisInfo) = "-+"(info.num).toString + underlying
   }
 
   /** Names of the form N_<outer>. Emitted by inliner, replaced by outer path
    *  in ExplicitOuter.
    */
-  val OuterSelectName = new NumberedNameKind(OUTERSELECT, "OuterSelect") {
+  val OuterSelectName: NumberedNameKind = new NumberedNameKind(OUTERSELECT, "OuterSelect") {
     def mkString(underlying: TermName, info: ThisInfo) = {
       assert(underlying.isEmpty)
       info.num + "_<outer>"
     }
   }
 
-  val SuperAccessorName = new PrefixNameKind(SUPERACCESSOR, "super$")
-  val InitializerName = new PrefixNameKind(INITIALIZER, "initial$")
-  val ProtectedAccessorName = new PrefixNameKind(PROTECTEDACCESSOR, "protected$")
-  val InlineAccessorName = new PrefixNameKind(INLINEACCESSOR, "inline$")
+  val SuperAccessorName: PrefixNameKind = new PrefixNameKind(SUPERACCESSOR, "super$")
+  val InitializerName: PrefixNameKind = new PrefixNameKind(INITIALIZER, "initial$")
+  val ProtectedAccessorName: PrefixNameKind = new PrefixNameKind(PROTECTEDACCESSOR, "protected$")
+  val InlineAccessorName: PrefixNameKind = new PrefixNameKind(INLINEACCESSOR, "inline$")
 
-  val AvoidClashName = new SuffixNameKind(AVOIDCLASH, "$_avoid_name_clash_$")
-  val DirectMethodName = new SuffixNameKind(DIRECT, "$direct") { override def definesNewName = true }
-  val FieldName = new SuffixNameKind(FIELD, "$$local") {
+  val AvoidClashName: SuffixNameKind = new SuffixNameKind(AVOIDCLASH, "$_avoid_name_clash_$")
+  val DirectMethodName: SuffixNameKind = new SuffixNameKind(DIRECT, "$direct") { override def definesNewName = true }
+  val FieldName: SuffixNameKind = new SuffixNameKind(FIELD, "$$local") {
       override def mkString(underlying: TermName, info: ThisInfo) = underlying.toString
   }
-  val ExtMethName = new SuffixNameKind(EXTMETH, "$extension")
-  val ModuleClassName = new SuffixNameKind(OBJECTCLASS, "$", optInfoString = "ModuleClass")
-  val ImplMethName = new SuffixNameKind(IMPLMETH, "$")
-  val AdaptedClosureName = new SuffixNameKind(ADAPTEDCLOSURE, "$adapted") { override def definesNewName = true }
+  val ExtMethName: SuffixNameKind = new SuffixNameKind(EXTMETH, "$extension")
+  val ModuleClassName: SuffixNameKind = new SuffixNameKind(OBJECTCLASS, "$", optInfoString = "ModuleClass")
+  val ImplMethName: SuffixNameKind = new SuffixNameKind(IMPLMETH, "$")
+  val AdaptedClosureName: SuffixNameKind = new SuffixNameKind(ADAPTEDCLOSURE, "$adapted") { override def definesNewName = true }
 
   /** A name together with a signature. Used in Tasty trees. */
   object SignedName extends NameKind(SIGNED) {
 
     case class SignedInfo(sig: Signature) extends Info {
       assert(sig ne Signature.NotAMethod)
-      override def toString = s"$infoString $sig"
+      override def toString: String = s"$infoString $sig"
     }
     type ThisInfo = SignedInfo
 
-    def apply(qual: TermName, sig: Signature) =
+    def apply(qual: TermName, sig: Signature): TermName =
       qual.derived(new SignedInfo(sig))
     def unapply(name: DerivedName): Option[(TermName, Signature)] = name match {
       case DerivedName(underlying, info: SignedInfo) => Some((underlying, info.sig))
diff --git a/compiler/src/dotty/tools/dotc/core/NameOps.scala b/compiler/src/dotty/tools/dotc/core/NameOps.scala
index 3abd919f89d9..b85c57dc8409 100644
--- a/compiler/src/dotty/tools/dotc/core/NameOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/NameOps.scala
@@ -2,19 +2,16 @@ package dotty.tools.dotc
 package core
 
 import java.security.MessageDigest
-import scala.annotation.switch
 import scala.io.Codec
-import Names._, StdNames._, Contexts._, Symbols._, Flags._, NameKinds._
-import Decorators.PreNamedString
-import util.{Chars, NameTransformer}
+import Names._, StdNames._, Contexts._, Symbols._, Flags._, NameKinds._, Types._
+import util.Chars
 import Chars.isOperatorPart
 import Definitions._
-import config.Config
 
 object NameOps {
 
   final object compactify {
-    lazy val md5 = MessageDigest.getInstance("MD5")
+    lazy val md5: MessageDigest = MessageDigest.getInstance("MD5")
 
     /** COMPACTIFY
      *
@@ -61,14 +58,14 @@ object NameOps {
     private def likeSpacedN(n: Name): N =
       name.likeSpaced(n).asInstanceOf[N]
 
-    def isConstructorName = name == CONSTRUCTOR || name == TRAIT_CONSTRUCTOR
-    def isStaticConstructorName = name == STATIC_CONSTRUCTOR
-    def isLocalDummyName = name startsWith str.LOCALDUMMY_PREFIX
-    def isReplWrapperName = name.toString contains str.REPL_SESSION_LINE
-    def isReplAssignName = name.toString contains str.REPL_ASSIGN_SUFFIX
-    def isSetterName = name endsWith str.SETTER_SUFFIX
-    def isScala2LocalSuffix = testSimple(_.endsWith(" "))
-    def isSelectorName = testSimple(n => n.startsWith("_") && n.drop(1).forall(_.isDigit))
+    def isConstructorName: Boolean = name == CONSTRUCTOR || name == TRAIT_CONSTRUCTOR
+    def isStaticConstructorName: Boolean = name == STATIC_CONSTRUCTOR
+    def isLocalDummyName: Boolean = name startsWith str.LOCALDUMMY_PREFIX
+    def isReplWrapperName: Boolean = name.toString contains str.REPL_SESSION_LINE
+    def isReplAssignName: Boolean = name.toString contains str.REPL_ASSIGN_SUFFIX
+    def isSetterName: Boolean = name endsWith str.SETTER_SUFFIX
+    def isScala2LocalSuffix: Boolean = testSimple(_.endsWith(" "))
+    def isSelectorName: Boolean = testSimple(n => n.startsWith("_") && n.drop(1).forall(_.isDigit))
 
     /** Is name a variable name? */
     def isVariableName: Boolean = testSimple { n =>
@@ -109,7 +106,7 @@ object NameOps {
     }
 
     /** If flags is a ModuleClass but not a Package, add module class suffix */
-    def adjustIfModuleClass(flags: Flags.FlagSet): N = likeSpacedN {
+    def adjustIfModuleClass(flags: FlagSet): N = likeSpacedN {
       if (flags is (ModuleClass, butNot = Package)) name.asTypeName.moduleClassName
       else name.toTermName.exclude(AvoidClashName)
     }
@@ -158,7 +155,7 @@ object NameOps {
     /** The variance as implied by the variance prefix, or 0 if there is
      *  no variance prefix.
      */
-    def variance = name.collect { case VariantName(_, n) => natToVariance(n) }.getOrElse(0)
+    def variance: Int = name.collect { case VariantName(_, n) => natToVariance(n) }.getOrElse(0)
 
     def freshened(implicit ctx: Context): N = likeSpacedN {
       name.toTermName match {
@@ -233,7 +230,7 @@ object NameOps {
       case nme.clone_ => nme.clone_
     }
 
-    def specializedFor(classTargs: List[Types.Type], classTargsNames: List[Name], methodTargs: List[Types.Type], methodTarsNames: List[Name])(implicit ctx: Context): N = {
+    def specializedFor(classTargs: List[Type], classTargsNames: List[Name], methodTargs: List[Type], methodTarsNames: List[Name])(implicit ctx: Context): N = {
 
       val methodTags: Seq[Name] = (methodTargs zip methodTarsNames).sortBy(_._2).map(x => defn.typeTag(x._1))
       val classTags: Seq[Name] = (classTargs zip classTargsNames).sortBy(_._2).map(x => defn.typeTag(x._1))
diff --git a/compiler/src/dotty/tools/dotc/core/Names.scala b/compiler/src/dotty/tools/dotc/core/Names.scala
index e2e5a9e60ab4..83d1a564edbf 100644
--- a/compiler/src/dotty/tools/dotc/core/Names.scala
+++ b/compiler/src/dotty/tools/dotc/core/Names.scala
@@ -6,13 +6,9 @@ import scala.io.Codec
 import util.NameTransformer
 import printing.{Showable, Texts, Printer}
 import Texts.Text
-import Decorators._
-import Contexts.Context
 import StdNames.str
 import util.Chars.isIdentifierStart
-import collection.IndexedSeqOptimized
 import collection.immutable
-import util.{DotClass}
 import config.Config
 import java.util.HashMap
 
@@ -157,19 +153,19 @@ object Names {
     /** Does (the last part of) this name end with `str`? */
     def endsWith(str: String): Boolean = lastPart.endsWith(str)
 
-    override def hashCode = System.identityHashCode(this)
-    override def equals(that: Any) = this eq that.asInstanceOf[AnyRef]
+    override def hashCode: Int = System.identityHashCode(this)
+    override def equals(that: Any): Boolean = this eq that.asInstanceOf[AnyRef]
   }
 
   /** Names for terms, can be simple or derived */
   abstract class TermName extends Name {
     type ThisName = TermName
 
-    override def isTypeName = false
-    override def isTermName = true
-    override def toTermName = this
-    override def asTypeName = throw new ClassCastException(this + " is not a type name")
-    override def asTermName = this
+    override def isTypeName: Boolean = false
+    override def isTermName: Boolean = true
+    override def toTermName: TermName = this
+    override def asTypeName: Nothing = throw new ClassCastException(this + " is not a type name")
+    override def asTermName: TermName = this
 
     @sharable // because it is only modified in the synchronized block of toTypeName.
     @volatile private[this] var _typeName: TypeName = null
@@ -284,7 +280,7 @@ object Names {
      *  `<first> <sep> <last>`, the sanitized version of `f1(<first>) <sep> f2(<last>)`.
      *  Otherwise `f2` applied to this name.
      */
-    def qualToString(f1: TermName => String, f2: TermName => String) = {
+    def qualToString(f1: TermName => String, f2: TermName => String): String = {
       val (first, last, sep) = split
       if (first.isEmpty) f2(last) else str.sanitize(f1(first) + sep + f2(last))
     }
@@ -295,7 +291,7 @@ object Names {
     // `next` is @sharable because it is only modified in the synchronized block of termName.
 
     /** The n'th character */
-    def apply(n: Int) = chrs(start + n)
+    def apply(n: Int): Char = chrs(start + n)
 
     /** A character in this name satisfies predicate `p` */
     def exists(p: Char => Boolean): Boolean = {
@@ -305,7 +301,7 @@ object Names {
     }
 
     /** All characters in this name satisfy predicate `p` */
-    def forall(p: Char => Boolean) = !exists(!p(_))
+    def forall(p: Char => Boolean): Boolean = !exists(!p(_))
 
     /** The name contains given character `ch` */
     def contains(ch: Char): Boolean = {
@@ -332,28 +328,28 @@ object Names {
       termName(chrs, start + from, end - from)
     }
 
-    def drop(n: Int) = slice(n, length)
-    def take(n: Int) = slice(0, n)
-    def dropRight(n: Int) = slice(0, length - n)
-    def takeRight(n: Int) = slice(length - n, length)
+    def drop(n: Int): SimpleName = slice(n, length)
+    def take(n: Int): SimpleName = slice(0, n)
+    def dropRight(n: Int): SimpleName = slice(0, length - n)
+    def takeRight(n: Int): SimpleName = slice(length - n, length)
 
     /** Same as slice, but as a string */
-    def sliceToString(from: Int, end: Int) =
+    def sliceToString(from: Int, end: Int): String =
       if (end <= from) "" else new String(chrs, start + from, end - from)
 
-    def head = apply(0)
-    def last = apply(length - 1)
+    def head: Char = apply(0)
+    def last: Char = apply(length - 1)
 
-    override def asSimpleName = this
-    override def toSimpleName = this
-    override final def mangle = encode
+    override def asSimpleName: SimpleName = this
+    override def toSimpleName: SimpleName = this
+    override final def mangle: SimpleName = encode
 
     override def replace(f: PartialFunction[Name, Name]): ThisName =
       if (f.isDefinedAt(this)) likeSpaced(f(this)) else this
     override def collect[T](f: PartialFunction[Name, T]): Option[T] = f.lift(this)
-    override def mapLast(f: SimpleName => SimpleName) = f(this)
-    override def mapParts(f: SimpleName => SimpleName) = f(this)
-    override def split = (EmptyTermName, this, "")
+    override def mapLast(f: SimpleName => SimpleName): SimpleName = f(this)
+    override def mapParts(f: SimpleName => SimpleName): SimpleName = f(this)
+    override def split: (TermName, SimpleName, String) = (EmptyTermName, this, "")
 
     override def encode: SimpleName = {
       val dontEncode =
@@ -364,7 +360,7 @@ object Names {
 
     override def decode: SimpleName = NameTransformer.decode(this)
 
-    override def isEmpty = length == 0
+    override def isEmpty: Boolean = length == 0
 
     override def startsWith(str: String): Boolean = {
       var i = 0
@@ -387,12 +383,12 @@ object Names {
       termName(cs, 0, length)
     }
 
-    override def firstPart = this
-    override def lastPart = this
+    override def firstPart: SimpleName = this
+    override def lastPart: SimpleName = this
 
     override def hashCode: Int = start
 
-    override def toString =
+    override def toString: String =
       if (length == 0) ""
       else {
         if (Config.checkBackendNames) {
@@ -436,37 +432,37 @@ object Names {
 
     type ThisName = TypeName
 
-    override def isTypeName = true
-    override def isTermName = false
-    override def toTypeName = this
-    override def asTypeName = this
-    override def asTermName = throw new ClassCastException(this + " is not a term name")
+    override def isTypeName: Boolean = true
+    override def isTermName: Boolean = false
+    override def toTypeName: TypeName = this
+    override def asTypeName: TypeName = this
+    override def asTermName: Nothing = throw new ClassCastException(this + " is not a term name")
 
-    override def asSimpleName = toTermName.asSimpleName
-    override def toSimpleName = toTermName.toSimpleName
-    override def mangled = toTermName.mangled.toTypeName
-    override def mangledString = toTermName.mangledString
+    override def asSimpleName: SimpleName = toTermName.asSimpleName
+    override def toSimpleName: SimpleName = toTermName.toSimpleName
+    override def mangled: TypeName = toTermName.mangled.toTypeName
+    override def mangledString: String = toTermName.mangledString
 
     override def replace(f: PartialFunction[Name, Name]): ThisName = toTermName.replace(f).toTypeName
     override def collect[T](f: PartialFunction[Name, T]): Option[T] = toTermName.collect(f)
-    override def mapLast(f: SimpleName => SimpleName) = toTermName.mapLast(f).toTypeName
-    override def mapParts(f: SimpleName => SimpleName) = toTermName.mapParts(f).toTypeName
+    override def mapLast(f: SimpleName => SimpleName): TypeName = toTermName.mapLast(f).toTypeName
+    override def mapParts(f: SimpleName => SimpleName): TypeName = toTermName.mapParts(f).toTypeName
 
     override def likeSpaced(name: Name): TypeName = name.toTypeName
 
     override def derived(info: NameInfo): TypeName = toTermName.derived(info).toTypeName
     override def exclude(kind: NameKind): TypeName = toTermName.exclude(kind).toTypeName
-    override def is(kind: NameKind) = toTermName.is(kind)
+    override def is(kind: NameKind): Boolean = toTermName.is(kind)
 
-    override def isEmpty = toTermName.isEmpty
+    override def isEmpty: Boolean = toTermName.isEmpty
 
-    override def encode   = toTermName.encode.toTypeName
-    override def decode   = toTermName.decode.toTypeName
-    override def firstPart = toTermName.firstPart
-    override def lastPart = toTermName.lastPart
+    override def encode: TypeName   = toTermName.encode.toTypeName
+    override def decode: TypeName   = toTermName.decode.toTypeName
+    override def firstPart: SimpleName = toTermName.firstPart
+    override def lastPart: SimpleName = toTermName.lastPart
 
-    override def toString = toTermName.toString
-    override def debugString = toTermName.debugString + "/T"
+    override def toString: String = toTermName.toString
+    override def debugString: String = toTermName.debugString + "/T"
   }
 
   /** A term name that's derived from an `underlying` name and that
@@ -475,10 +471,10 @@ object Names {
   final case class DerivedName(override val underlying: TermName, override val info: NameInfo)
   extends TermName {
 
-    override def asSimpleName = throw new UnsupportedOperationException(s"$debugString is not a simple name")
+    override def asSimpleName: Nothing = throw new UnsupportedOperationException(s"$debugString is not a simple name")
 
-    override def toSimpleName = termName(toString)
-    override final def mangle = encode.toSimpleName
+    override def toSimpleName: SimpleName = termName(toString)
+    override final def mangle: SimpleName = encode.toSimpleName
 
     override def replace(f: PartialFunction[Name, Name]): ThisName =
       if (f.isDefinedAt(this)) likeSpaced(f(this))
@@ -506,7 +502,7 @@ object Names {
         case _ => underlying.mapParts(f).derived(info)
       }
 
-    override def split = info match {
+    override def split: (TermName, TermName, String) = info match {
       case info: QualifiedInfo =>
         (underlying, info.name, info.kind.asInstanceOf[QualifiedNameKind].separator)
       case _ =>
@@ -514,16 +510,16 @@ object Names {
         (prefix, suffix.derived(info), separator)
     }
 
-    override def isEmpty = false
+    override def isEmpty: Boolean = false
     override def encode: ThisName = underlying.encode.derived(info.map(_.encode))
     override def decode: ThisName = underlying.decode.derived(info.map(_.decode))
-    override def firstPart = underlying.firstPart
-    override def lastPart = info match {
+    override def firstPart: SimpleName = underlying.firstPart
+    override def lastPart: SimpleName = info match {
       case qual: QualifiedInfo => qual.name
       case _ => underlying.lastPart
     }
-    override def toString = info.mkString(underlying)
-    override def debugString = s"${underlying.debugString}[$info]"
+    override def toString: String = info.mkString(underlying)
+    override def debugString: String = s"${underlying.debugString}[$info]"
   }
 
   // Nametable
@@ -661,7 +657,7 @@ object Names {
   val EmptyTermName: TermName = table(0)
 
   /** The type name represented by the empty string */
-  val EmptyTypeName = EmptyTermName.toTypeName
+  val EmptyTypeName: TypeName = EmptyTermName.toTypeName
 
   implicit val NameOrdering: Ordering[Name] = new Ordering[Name] {
     private def compareInfos(x: NameInfo, y: NameInfo): Int =
diff --git a/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala b/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
index 6d834b864131..f128f4e2022b 100644
--- a/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
+++ b/compiler/src/dotty/tools/dotc/core/OrderingConstraint.scala
@@ -5,10 +5,9 @@ package core
 import Types._, Contexts._, Symbols._, Decorators._
 import util.SimpleIdentityMap
 import collection.mutable
-import printing.{Printer, Showable}
+import printing.Printer
 import printing.Texts._
 import config.Config
-import collection.immutable.BitSet
 import reflect.ClassTag
 import annotation.tailrec
 
@@ -36,7 +35,7 @@ object OrderingConstraint {
     def updateEntries(c: OrderingConstraint, poly: TypeLambda, entries: Array[T])(implicit ctx: Context): OrderingConstraint
     def initial: T
 
-    def apply(c: OrderingConstraint, poly: TypeLambda, idx: Int) = {
+    def apply(c: OrderingConstraint, poly: TypeLambda, idx: Int): T = {
       val es = entries(c, poly)
       if (es == null) initial else es(idx)
     }
@@ -80,7 +79,7 @@ object OrderingConstraint {
       map(prev, current, param.binder, param.paramNum, f)
   }
 
-  val boundsLens = new ConstraintLens[Type] {
+  val boundsLens: ConstraintLens[Type] = new ConstraintLens[Type] {
     def entries(c: OrderingConstraint, poly: TypeLambda): Array[Type] =
       c.boundsMap(poly)
     def updateEntries(c: OrderingConstraint, poly: TypeLambda, entries: Array[Type])(implicit ctx: Context): OrderingConstraint =
@@ -88,7 +87,7 @@ object OrderingConstraint {
     def initial = NoType
   }
 
-  val lowerLens = new ConstraintLens[List[TypeParamRef]] {
+  val lowerLens: ConstraintLens[List[TypeParamRef]] = new ConstraintLens[List[TypeParamRef]] {
     def entries(c: OrderingConstraint, poly: TypeLambda): Array[List[TypeParamRef]] =
       c.lowerMap(poly)
     def updateEntries(c: OrderingConstraint, poly: TypeLambda, entries: Array[List[TypeParamRef]])(implicit ctx: Context): OrderingConstraint =
@@ -96,7 +95,7 @@ object OrderingConstraint {
     def initial = Nil
   }
 
-  val upperLens = new ConstraintLens[List[TypeParamRef]] {
+  val upperLens: ConstraintLens[List[TypeParamRef]] = new ConstraintLens[List[TypeParamRef]] {
     def entries(c: OrderingConstraint, poly: TypeLambda): Array[List[TypeParamRef]] =
       c.upperMap(poly)
     def updateEntries(c: OrderingConstraint, poly: TypeLambda, entries: Array[List[TypeParamRef]])(implicit ctx: Context): OrderingConstraint =
@@ -501,7 +500,7 @@ class OrderingConstraint(private val boundsMap: ParamBounds,
       }
     }
 
-  def & (other: Constraint, otherHasErrors: Boolean)(implicit ctx: Context) = {
+  def & (other: Constraint, otherHasErrors: Boolean)(implicit ctx: Context): OrderingConstraint = {
     def merge[T](m1: ArrayValuedMap[T], m2: ArrayValuedMap[T], join: (T, T) => T): ArrayValuedMap[T] = {
       var merged = m1
       def mergeArrays(xs1: Array[T], xs2: Array[T]) = {
diff --git a/compiler/src/dotty/tools/dotc/core/Periods.scala b/compiler/src/dotty/tools/dotc/core/Periods.scala
index 381593246495..1976b8a171ad 100644
--- a/compiler/src/dotty/tools/dotc/core/Periods.scala
+++ b/compiler/src/dotty/tools/dotc/core/Periods.scala
@@ -1,7 +1,6 @@
 package dotty.tools.dotc.core
 
 import Contexts._
-import dotty.tools.dotc.util.DotClass
 
 /** Periods are the central "clock" of the compiler.
  *  A period consists of a run id and a phase id.
@@ -30,7 +29,7 @@ abstract class Periods { self: Context =>
    *  the current phase that has the same "nextTransformerId". As last phase
    *  we take the next transformer id following the current phase.
    */
-  def stablePeriod = {
+  def stablePeriod: Period = {
     var first = phaseId
     val nxTrans = ctx.base.nextDenotTransformerId(first)
     while (first - 1 > NoPhaseId && (ctx.base.nextDenotTransformerId(first - 1) == nxTrans)) {
@@ -40,7 +39,7 @@ abstract class Periods { self: Context =>
   }
 
   /** Are all base types in the current period guaranteed to be the same as in period `p`? */
-  def hasSameBaseTypesAs(p: Period) = {
+  def hasSameBaseTypesAs(p: Period): Boolean = {
     val period = this.period
     period == p ||
     period.runId == p.runId &&
@@ -74,9 +73,9 @@ object Periods {
       (code >>> PhaseWidth) & PhaseMask
 
     /** The first phase of this period */
-    def firstPhaseId = lastPhaseId - (code & PhaseMask)
+    def firstPhaseId: Int = lastPhaseId - (code & PhaseMask)
 
-    def containsPhaseId(id: PhaseId) = firstPhaseId <= id && id <= lastPhaseId
+    def containsPhaseId(id: PhaseId): Boolean = firstPhaseId <= id && id <= lastPhaseId
 
     /** Does this period contain given period? */
     def contains(that: Period): Boolean = {
@@ -123,7 +122,7 @@ object Periods {
           this.firstPhaseId min that.firstPhaseId,
           this.lastPhaseId max that.lastPhaseId)
 
-    override def toString = s"Period($firstPhaseId..$lastPhaseId, run = $runId)"
+    override def toString: String = s"Period($firstPhaseId..$lastPhaseId, run = $runId)"
   }
 
   object Period {
@@ -139,16 +138,16 @@ object Periods {
     }
 
     /** The interval consisting of all periods of given run id */
-    def allInRun(rid: RunId) = {
+    def allInRun(rid: RunId): Period = {
       apply(rid, 0, PhaseMask)
     }
   }
 
-  final val Nowhere = new Period(0)
+  final val Nowhere: Period = new Period(0)
 
-  final val InitialPeriod = Period(InitialRunId, FirstPhaseId)
+  final val InitialPeriod: Period = Period(InitialRunId, FirstPhaseId)
 
-  final val InvalidPeriod = Period(NoRunId, NoPhaseId)
+  final val InvalidPeriod: Period = Period(NoRunId, NoPhaseId)
 
   /** An ordinal number for compiler runs. First run has number 1. */
   type RunId = Int
diff --git a/compiler/src/dotty/tools/dotc/core/Phases.scala b/compiler/src/dotty/tools/dotc/core/Phases.scala
index 0269c6f536ee..cb9be7b30b74 100644
--- a/compiler/src/dotty/tools/dotc/core/Phases.scala
+++ b/compiler/src/dotty/tools/dotc/core/Phases.scala
@@ -5,13 +5,11 @@ package core
 import Periods._
 import Contexts._
 import dotty.tools.backend.jvm.{LabelDefs, GenBCode}
-import dotty.tools.dotc.core.Symbols.ClassSymbol
-import util.DotClass
 import DenotTransformers._
 import Denotations._
 import Decorators._
 import config.Printers.config
-import scala.collection.mutable.{ListBuffer, ArrayBuffer}
+import scala.collection.mutable.ListBuffer
 import dotty.tools.dotc.transform.MegaPhase._
 import dotty.tools.dotc.transform._
 import Periods._
@@ -50,31 +48,31 @@ object Phases {
     this: ContextBase =>
 
     // drop NoPhase at beginning
-    def allPhases = (if (squashedPhases.nonEmpty) squashedPhases else phases).tail
+    def allPhases: Array[Phase] = (if (squashedPhases.nonEmpty) squashedPhases else phases).tail
 
     object NoPhase extends Phase {
-      override def exists = false
-      def phaseName = "<no phase>"
+      override def exists: Boolean = false
+      def phaseName: String = "<no phase>"
       def run(implicit ctx: Context): Unit = unsupported("run")
       def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = unsupported("transform")
     }
 
     object SomePhase extends Phase {
-      def phaseName = "<some phase>"
+      def phaseName: String = "<some phase>"
       def run(implicit ctx: Context): Unit = unsupported("run")
     }
 
     /** A sentinel transformer object */
     class TerminalPhase extends DenotTransformer {
-      def phaseName = "terminal"
+      def phaseName: String = "terminal"
       def run(implicit ctx: Context): Unit = unsupported("run")
       def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation =
         unsupported("transform")
-      override def lastPhaseId(implicit ctx: Context) = id
+      override def lastPhaseId(implicit ctx: Context): Int = id
     }
 
-    final def phasePlan = this.phasesPlan
-    final def setPhasePlan(phasess: List[List[Phase]]) = this.phasesPlan = phasess
+    final def phasePlan: List[List[Phase]] = this.phasesPlan
+    final def setPhasePlan(phasess: List[List[Phase]]): Unit = this.phasesPlan = phasess
 
     /** Squash TreeTransform's beloning to same sublist to a single TreeTransformer
       * Each TreeTransform gets own period,
@@ -136,7 +134,7 @@ object Phases {
      *  The list should never contain NoPhase.
      *  if squashing is enabled, phases in same subgroup will be squashed to single phase.
      */
-    final def usePhases(phasess: List[Phase], squash: Boolean = true) = {
+    final def usePhases(phasess: List[Phase], squash: Boolean = true): Unit = {
 
       val flatPhases = collection.mutable.ListBuffer[Phase]()
 
@@ -225,21 +223,21 @@ object Phases {
     private[this] var myFlattenPhase: Phase = _
     private[this] var myGenBCodePhase: Phase = _
 
-    final def typerPhase = myTyperPhase
-    final def sbtExtractDependenciesPhase = mySbtExtractDependenciesPhase
-    final def picklerPhase = myPicklerPhase
-    final def collectNullableFieldsPhase = myCollectNullableFieldsPhase
-    final def refchecksPhase = myRefChecksPhase
-    final def patmatPhase = myPatmatPhase
-    final def elimRepeatedPhase = myElimRepeatedPhase
-    final def extensionMethodsPhase = myExtensionMethodsPhase
-    final def explicitOuterPhase = myExplicitOuterPhase
-    final def gettersPhase = myGettersPhase
-    final def erasurePhase = myErasurePhase
-    final def elimErasedValueTypePhase = myElimErasedValueTypePhase
-    final def lambdaLiftPhase = myLambdaLiftPhase
-    final def flattenPhase = myFlattenPhase
-    final def genBCodePhase = myGenBCodePhase
+    final def typerPhase: Phase = myTyperPhase
+    final def sbtExtractDependenciesPhase: Phase = mySbtExtractDependenciesPhase
+    final def picklerPhase: Phase = myPicklerPhase
+    final def collectNullableFieldsPhase: Phase = myCollectNullableFieldsPhase
+    final def refchecksPhase: Phase = myRefChecksPhase
+    final def patmatPhase: Phase = myPatmatPhase
+    final def elimRepeatedPhase: Phase = myElimRepeatedPhase
+    final def extensionMethodsPhase: Phase = myExtensionMethodsPhase
+    final def explicitOuterPhase: Phase = myExplicitOuterPhase
+    final def gettersPhase: Phase = myGettersPhase
+    final def erasurePhase: Phase = myErasurePhase
+    final def elimErasedValueTypePhase: Phase = myElimErasedValueTypePhase
+    final def lambdaLiftPhase: Phase = myLambdaLiftPhase
+    final def flattenPhase: Phase = myFlattenPhase
+    final def genBCodePhase: Phase = myGenBCodePhase
 
     private def setSpecificPhases() = {
       def phaseOfClass(pclass: Class[_]) = phases.find(pclass.isInstance).getOrElse(NoPhase)
@@ -314,7 +312,7 @@ object Phases {
      *  is tested in some places that perform checks and corrections. It's
      *  different from isAfterTyper (and cheaper to test).
      */
-    def isTyper = false
+    def isTyper: Boolean = false
 
     /** Can this transform create or delete non-private members? */
     def changesMembers: Boolean = false
@@ -340,20 +338,20 @@ object Phases {
      * is reserved for NoPhase and the first real phase is at position 1.
      * -1 if the phase is not installed in the context.
      */
-    def id = myPeriod.firstPhaseId
+    def id: Int = myPeriod.firstPhaseId
 
-    def period = myPeriod
-    def start = myPeriod.firstPhaseId
-    def end = myPeriod.lastPhaseId
+    def period: Period = myPeriod
+    def start: Int = myPeriod.firstPhaseId
+    def end: Periods.PhaseId = myPeriod.lastPhaseId
 
-    final def erasedTypes = myErasedTypes   // Phase is after erasure
-    final def flatClasses = myFlatClasses   // Phase is after flatten
-    final def refChecked = myRefChecked     // Phase is after RefChecks
-    final def labelsReordered = myLabelsReordered // Phase is after LabelDefs, labels are flattened and owner chains don't mirror this
+    final def erasedTypes: Boolean = myErasedTypes   // Phase is after erasure
+    final def flatClasses: Boolean = myFlatClasses   // Phase is after flatten
+    final def refChecked: Boolean = myRefChecked     // Phase is after RefChecks
+    final def labelsReordered: Boolean = myLabelsReordered // Phase is after LabelDefs, labels are flattened and owner chains don't mirror this
 
-    final def sameMembersStartId = mySameMembersStartId
+    final def sameMembersStartId: Int = mySameMembersStartId
       // id of first phase where all symbols are guaranteed to have the same members as in this phase
-    final def sameParentsStartId = mySameParentsStartId
+    final def sameParentsStartId: Int = mySameParentsStartId
       // id of first phase where all symbols are guaranteed to have the same parents as in this phase
 
     protected[Phases] def init(base: ContextBase, start: Int, end: Int): Unit = {
@@ -372,7 +370,7 @@ object Phases {
 
     protected[Phases] def init(base: ContextBase, id: Int): Unit = init(base, id, id)
 
-    final def <=(that: Phase) =
+    final def <=(that: Phase): Boolean =
       exists && id <= that.id
 
     final def prev: Phase =
@@ -381,12 +379,12 @@ object Phases {
     final def next: Phase =
       if (hasNext) myBase.phases(end + 1) else myBase.NoPhase
 
-    final def hasNext = start >= FirstPhaseId && end + 1 < myBase.phases.length
+    final def hasNext: Boolean = start >= FirstPhaseId && end + 1 < myBase.phases.length
 
-    final def iterator =
+    final def iterator: Iterator[Phase] =
       Iterator.iterate(this)(_.next) takeWhile (_.hasNext)
 
-    override def toString = phaseName
+    override def toString: String = phaseName
   }
 
   /** Replace all instances of `oldPhaseClass` in `current` phases
diff --git a/compiler/src/dotty/tools/dotc/core/Scopes.scala b/compiler/src/dotty/tools/dotc/core/Scopes.scala
index d4d6f6d734de..4ed90ed7bfdd 100644
--- a/compiler/src/dotty/tools/dotc/core/Scopes.scala
+++ b/compiler/src/dotty/tools/dotc/core/Scopes.scala
@@ -11,15 +11,12 @@ import Symbols._
 import Types.{TermRef, NoPrefix}
 import Flags.Implicit
 import Names._
-import Periods._
-import Decorators._
 import Contexts._
 import Denotations._
 import SymDenotations._
 import printing.Texts._
 import printing.Printer
 import util.common._
-import util.DotClass
 import SymDenotations.NoDenotation
 import collection.mutable
 
@@ -175,7 +172,7 @@ object Scopes {
 
     final def toText(printer: Printer): Text = printer.toText(this)
 
-    def checkConsistent()(implicit ctx: Context) = ()
+    def checkConsistent()(implicit ctx: Context): Unit = ()
 
     /** Ensure that all elements of this scope have been entered.
      *  Overridden by SymbolLoaders.PackageLoader#PackageScope, where it
@@ -206,7 +203,7 @@ object Scopes {
     /** The size of the scope */
     private[this] var _size = initSize
 
-    override final def size = _size
+    override final def size: Int = _size
     private def size_= (x: Int) = _size = x
 
     /** the hash table
@@ -223,7 +220,7 @@ object Scopes {
     /** Use specified synthesize for this scope */
     def useSynthesizer(s: SymbolSynthesizer): Unit = synthesize = s
 
-    protected def newScopeLikeThis() = new MutableScope()
+    protected def newScopeLikeThis(): MutableScope = new MutableScope()
 
     /** Clone scope, taking care not to force the denotations of any symbols in the scope.
      */
@@ -428,7 +425,7 @@ object Scopes {
     override def openForMutations: MutableScope = this
 
     /** Check that all symbols in this scope are in their correct hashtable buckets. */
-    override def checkConsistent()(implicit ctx: Context) = {
+    override def checkConsistent()(implicit ctx: Context): Unit = {
       ensureComplete()
       var e = lastEntry
       while (e != null) {
@@ -465,10 +462,10 @@ object Scopes {
   /** The empty scope (immutable).
    */
   object EmptyScope extends Scope {
-    override private[dotc] def lastEntry = null
-    override def size = 0
-    override def nestingLevel = 0
-    override def toList(implicit ctx: Context) = Nil
+    override private[dotc] def lastEntry: ScopeEntry = null
+    override def size: Int = 0
+    override def nestingLevel: Int = 0
+    override def toList(implicit ctx: Context): List[Symbol] = Nil
     override def cloneScope(implicit ctx: Context): MutableScope = unsupported("cloneScope")
     override def lookupEntry(name: Name)(implicit ctx: Context): ScopeEntry = null
     override def lookupNextEntry(entry: ScopeEntry)(implicit ctx: Context): ScopeEntry = null
diff --git a/compiler/src/dotty/tools/dotc/core/Signature.scala b/compiler/src/dotty/tools/dotc/core/Signature.scala
index b9856dcb8e4f..d52593fbb950 100644
--- a/compiler/src/dotty/tools/dotc/core/Signature.scala
+++ b/compiler/src/dotty/tools/dotc/core/Signature.scala
@@ -90,32 +90,32 @@ case class Signature(paramsSig: List[TypeName], resSig: TypeName) {
    *
    *  Like Signature#apply, the result is only cacheable if `isUnderDefined == false`.
    */
-  def prepend(params: List[Type], isJava: Boolean)(implicit ctx: Context) =
+  def prepend(params: List[Type], isJava: Boolean)(implicit ctx: Context): Signature =
     Signature(params.map(p => sigName(p, isJava)) ++ paramsSig, resSig)
 
   /** A signature is under-defined if its paramsSig part contains at least one
    *  `tpnme.Uninstantiated`. Under-defined signatures arise when taking a signature
    *  of a type that still contains uninstantiated type variables.
    */
-  def isUnderDefined(implicit ctx: Context) =
+  def isUnderDefined(implicit ctx: Context): Boolean =
     paramsSig.contains(tpnme.Uninstantiated) || resSig == tpnme.Uninstantiated
 }
 
 object Signature {
 
   type MatchDegree = Int
-  val NoMatch = 0
-  val ParamMatch = 1
-  val FullMatch = 2
+  val NoMatch: Int = 0
+  val ParamMatch: Int = 1
+  val FullMatch: Int = 2
 
   /** The signature of everything that's not a method, i.e. that has
    *  a type different from PolyType, MethodType, or ExprType.
    */
-  val NotAMethod = Signature(List(), EmptyTypeName)
+  val NotAMethod: Signature = Signature(List(), EmptyTypeName)
 
   /** The signature of an overloaded denotation.
    */
-  val OverloadedSignature = Signature(List(tpnme.OVERLOADED), EmptyTypeName)
+  val OverloadedSignature: Signature = Signature(List(tpnme.OVERLOADED), EmptyTypeName)
 
   /** The signature of a method with no parameters and result type `resultType`.
    *
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index 03c3f49ff94a..d020b3eb7ffc 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -2,13 +2,11 @@ package dotty.tools.dotc
 package core
 
 import scala.language.implicitConversions
-import scala.collection.{mutable, immutable}
+import scala.collection.mutable
 import scala.annotation.switch
 import Names._
 import Symbols._
 import Contexts._
-import Decorators.PreNamedString
-import util.NameTransformer
 
 object StdNames {
 
@@ -42,7 +40,7 @@ object StdNames {
     final val Tuple                      = "Tuple"
     final val Product                    = "Product"
 
-    def sanitize(str: String) = str.replaceAll("""[<>]""", """\$""")
+    def sanitize(str: String): String = str.replaceAll("""[<>]""", """\$""")
   }
 
   abstract class DefinedNames[N <: Name] {
@@ -50,7 +48,7 @@ object StdNames {
     protected def fromName(name: Name): N = fromString(name.toString)
 
     private val kws = mutable.Set[N]()
-    protected def kw(name: N) = { kws += name; name }
+    protected def kw(name: N): N = { kws += name; name }
 
     final val keywords: collection.Set[N] = kws
   }
@@ -562,7 +560,7 @@ object StdNames {
     val nothingClass: N         = "Nothing$"
     val nullClass: N            = "Null$"
 
-    val falseModuleClassNames = Set(nothingClass, nullClass, nothingRuntimeClass, nullRuntimeClass)
+    val falseModuleClassNames: Set[N] = Set(nothingClass, nullClass, nothingRuntimeClass, nullRuntimeClass)
 
     // unencoded operators
     object raw {
@@ -613,8 +611,6 @@ object StdNames {
     val toCharacter: N = "toCharacter"
     val toInteger: N   = "toInteger"
 
-    def newLazyValSlowComputeName(lzyValName: N) = lzyValName ++ LAZY_SLOW_SUFFIX
-
     // ASCII names for operators
     val ADD      : N = "+"
     val AND      : N = "&"
@@ -634,8 +630,8 @@ object StdNames {
     val MUL      : N = "*"
     val NE       : N = "!="
     val OR       : N = "|"
-    val PLUS     = ADD    // technically redundant, but ADD looks funny with MINUS
-    val SUB      = MINUS  // ... as does SUB with PLUS
+    val PLUS     : N = ADD    // technically redundant, but ADD looks funny with MINUS
+    val SUB      : N = MINUS  // ... as does SUB with PLUS
     val XOR      : N = "^"
     val ZAND     : N = "&&"
     val ZOR      : N = "||"
@@ -648,11 +644,11 @@ object StdNames {
     val UNARY_! : N = "unary_!"
 
     // Grouped here so Cleanup knows what tests to perform.
-    val CommonOpNames   = Set[Name](OR, XOR, AND, EQ, NE)
-    val ConversionNames = Set[Name](toByte, toChar, toDouble, toFloat, toInt, toLong, toShort)
-    val BooleanOpNames  = Set[Name](ZOR, ZAND, UNARY_!) ++ CommonOpNames
-    val NumberOpNames   = (
-         Set[Name](ADD, SUB, MUL, DIV, MOD, LSL, LSR, ASR, LT, LE, GE, GT)
+    val CommonOpNames: Set[Name]   = Set(OR, XOR, AND, EQ, NE)
+    val ConversionNames: Set[Name] = Set(toByte, toChar, toDouble, toFloat, toInt, toLong, toShort)
+    val BooleanOpNames: Set[Name]  = Set(ZOR, ZAND, UNARY_!) ++ CommonOpNames
+    val NumberOpNames: Set[Name]   = (
+         Set(ADD, SUB, MUL, DIV, MOD, LSL, LSR, ASR, LT, LE, GE, GT)
       ++ Set(UNARY_+, UNARY_-, UNARY_!)
       ++ ConversionNames
       ++ CommonOpNames
@@ -743,7 +739,7 @@ object StdNames {
       val names: Set[Name] = Set(arrayApply, arrayUpdate, arrayLength)
     }
 
-    def isPrimitiveName(name: Name) = primitive.names.contains(name)
+    def isPrimitiveName(name: Name): Boolean = primitive.names.contains(name)
   }
 
   class ScalaTypeNames extends ScalaNames[TypeName] {
@@ -751,7 +747,7 @@ object StdNames {
 
     def syntheticTypeParamName(i: Int): TypeName = "X" + i
 
-    final val Conforms = encode("<:<")
+    final val Conforms: TypeName = encode("<:<")
 
     final val Uninstantiated: TypeName = "?$"
   }
@@ -847,8 +843,8 @@ object StdNames {
     protected def fromString(s: String): TypeName = typeName(s)
   }
 
-  val nme = new ScalaTermNames
-  val tpnme = new ScalaTypeNames
-  val jnme = new JavaTermNames
-  val jtpnme = new JavaTypeNames
+  val nme:    ScalaTermNames = new ScalaTermNames
+  val tpnme:  ScalaTypeNames = new ScalaTypeNames
+  val jnme:   JavaTermNames  = new JavaTermNames
+  val jtpnme: JavaTypeNames  = new JavaTypeNames
 }
diff --git a/compiler/src/dotty/tools/dotc/core/Substituters.scala b/compiler/src/dotty/tools/dotc/core/Substituters.scala
index 9b366d22b804..ab07a4d568fd 100644
--- a/compiler/src/dotty/tools/dotc/core/Substituters.scala
+++ b/compiler/src/dotty/tools/dotc/core/Substituters.scala
@@ -1,6 +1,6 @@
 package dotty.tools.dotc.core
 
-import Types._, Symbols._, Contexts._, Names._
+import Types._, Symbols._, Contexts._
 
 /** Substitution operations on types. See the corresponding `subst` and
  *  `substThis` methods on class Type for an explanation.
@@ -161,15 +161,15 @@ trait Substituters { this: Context =>
     }
 
   final class SubstBindingMap(from: BindingType, to: BindingType) extends DeepTypeMap {
-    def apply(tp: Type) = subst(tp, from, to, this)
+    def apply(tp: Type): Type = subst(tp, from, to, this)
   }
 
   final class Subst1Map(from: Symbol, to: Type) extends DeepTypeMap {
-    def apply(tp: Type) = subst1(tp, from, to, this)
+    def apply(tp: Type): Type = subst1(tp, from, to, this)
   }
 
   final class Subst2Map(from1: Symbol, to1: Type, from2: Symbol, to2: Type) extends DeepTypeMap {
-    def apply(tp: Type) = subst2(tp, from1, to1, from2, to2, this)
+    def apply(tp: Type): Type = subst2(tp, from1, to1, from2, to2, this)
   }
 
   final class SubstMap(from: List[Symbol], to: List[Type]) extends DeepTypeMap {
@@ -189,10 +189,10 @@ trait Substituters { this: Context =>
   }
 
   final class SubstParamMap(from: ParamRef, to: Type) extends DeepTypeMap {
-    def apply(tp: Type) = substParam(tp, from, to, this)
+    def apply(tp: Type): Type = substParam(tp, from, to, this)
   }
 
   final class SubstParamsMap(from: BindingType, to: List[Type]) extends DeepTypeMap {
-    def apply(tp: Type) = substParams(tp, from, to, this)
+    def apply(tp: Type): Type = substParams(tp, from, to, this)
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index 28caa658d24e..26295efd2288 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -3,23 +3,18 @@ package dotc
 package core
 
 import Periods._, Contexts._, Symbols._, Denotations._, Names._, NameOps._, Annotations._
-import Types._, Flags._, Decorators._, DenotTransformers._, StdNames._, Scopes._, Comments._
+import Types._, Flags._, Decorators._, DenotTransformers._, StdNames._, Scopes._
 import NameOps._, NameKinds._, Phases._
 import TypeApplications.TypeParamInfo
 import Scopes.Scope
-import collection.mutable
-import collection.BitSet
 import dotty.tools.io.AbstractFile
 import Decorators.SymbolIteratorDecorator
 import ast._
-import ast.Trees._
 import annotation.tailrec
-import CheckRealizable._
 import util.SimpleIdentityMap
 import util.Stats
 import java.util.WeakHashMap
 import config.Config
-import config.Printers.noPrinter
 import reporting.diagnostic.Message
 import reporting.diagnostic.messages.BadSymbolicReference
 import reporting.trace
@@ -104,7 +99,7 @@ trait SymDenotations { this: Context =>
   }
 
   /** Configurable: Accept stale symbol with warning if in IDE */
-  def staleOK = Config.ignoreStaleInIDE && mode.is(Mode.Interactive)
+  def staleOK: Boolean = Config.ignoreStaleInIDE && mode.is(Mode.Interactive)
 
   /** Possibly accept stale symbol with warning if in IDE */
   def acceptStale(denot: SingleDenotation): Boolean =
@@ -153,7 +148,7 @@ object SymDenotations {
     /** The flag set without forcing symbol completion.
      *  Should be used only for printing.
      */
-    private[dotc] final def flagsUNSAFE = myFlags
+    private[dotc] final def flagsUNSAFE: FlagSet = myFlags
 
     /** Adapt flag set to this denotation's term or type nature */
     private def adaptFlags(flags: FlagSet) = if (isType) flags.toTypeFlags else flags.toTermFlags
@@ -183,27 +178,27 @@ object SymDenotations {
         else AfterLoadFlags)
 
     /** Has this denotation one of the flags in `fs` set? */
-    final def is(fs: FlagSet)(implicit ctx: Context) =
+    final def is(fs: FlagSet)(implicit ctx: Context): Boolean =
       (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?
      */
-    final def is(fs: FlagSet, butNot: FlagSet)(implicit ctx: Context) =
+    final def is(fs: FlagSet, butNot: FlagSet)(implicit ctx: Context): Boolean =
       (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags) is (fs, butNot)
 
     /** Has this denotation all of the flags in `fs` set? */
-    final def is(fs: FlagConjunction)(implicit ctx: Context) =
+    final def is(fs: FlagConjunction)(implicit ctx: Context): Boolean =
       (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?
      */
-    final def is(fs: FlagConjunction, butNot: FlagSet)(implicit ctx: Context) =
+    final def is(fs: FlagConjunction, butNot: FlagSet)(implicit ctx: Context): Boolean =
       (if (isCurrent(fs) && isCurrent(butNot)) myFlags else flags) is (fs, butNot)
 
     /** The type info, or, if symbol is not yet completed, the completer */
-    final def infoOrCompleter = myInfo
+    final def infoOrCompleter: Type = myInfo
 
     /** Optionally, the info if it is completed */
     final def unforcedInfo: Option[Type] = myInfo match {
@@ -237,7 +232,7 @@ object SymDenotations {
         completer.complete(this)(ctx.withPhase(validFor.firstPhaseId))
       }
 
-    protected[dotc] def info_=(tp: Type) = {
+    protected[dotc] def info_=(tp: Type): Unit = {
       /* // DEBUG
        def illegal: String = s"illegal type for $this: $tp"
       if (this is Module) // make sure module invariants that allow moduleClass and sourceModule to work are kept.
@@ -257,7 +252,7 @@ object SymDenotations {
      *   - if this is a companion object with a clash-avoiding name, strip the
      *     "avoid clash" suffix
      */
-    def effectiveName(implicit ctx: Context) =
+    def effectiveName(implicit ctx: Context): Name =
       if (this is ModuleClass) name.stripModuleClassSuffix
       else name.exclude(AvoidClashName)
 
@@ -279,7 +274,7 @@ object SymDenotations {
       myAnnotations = annots
 
     /** Does this denotation have an annotation matching the given class symbol? */
-    final def hasAnnotation(cls: Symbol)(implicit ctx: Context) =
+    final def hasAnnotation(cls: Symbol)(implicit ctx: Context): Boolean =
       dropOtherAnnotations(annotations, cls).nonEmpty
 
     /** Apply transform `f` to all annotations of this denotation */
@@ -373,14 +368,14 @@ object SymDenotations {
     // ------ Names ----------------------------------------------
 
     /** The expanded name of this denotation. */
-    final def expandedName(implicit ctx: Context) =
+    final def expandedName(implicit ctx: Context): Name =
       if (name.is(ExpandedName) || isConstructor) name
       else name.expandedName(initial.owner)
         // need to use initial owner to disambiguate, as multiple private symbols with the same name
         // might have been moved from different origins into the same class
 
     /** The name with which the denoting symbol was created */
-    final def originalName(implicit ctx: Context) = initial.effectiveName
+    final def originalName(implicit ctx: Context): Name = initial.effectiveName
 
     /** The encoded full path name of this denotation, where outer names and inner names
      *  are separated by `separator` strings as indicated by the given name kind.
@@ -431,7 +426,7 @@ object SymDenotations {
     final def isClass: Boolean = isInstanceOf[ClassDenotation]
 
     /** Is this denotation a non-trait class? */
-    final def isRealClass(implicit ctx: Context) = isClass && !is(Trait)
+    final def isRealClass(implicit ctx: Context): Boolean = isClass && !is(Trait)
 
     /** Cast to class denotation */
     final def asClass: ClassDenotation = asInstanceOf[ClassDenotation]
@@ -464,16 +459,16 @@ object SymDenotations {
       name.toTermName == nme.EMPTY_PACKAGE && owner.isRoot
 
     /** Is this symbol the empty package class or its companion object? */
-    final def isEffectiveRoot(implicit ctx: Context) = isRoot || isEmptyPackage
+    final def isEffectiveRoot(implicit ctx: Context): Boolean = isRoot || isEmptyPackage
 
     /** Is this symbol an anonymous class? */
     final def isAnonymousClass(implicit ctx: Context): Boolean =
       isClass && (initial.name startsWith str.ANON_CLASS)
 
-    final def isAnonymousFunction(implicit ctx: Context) =
+    final def isAnonymousFunction(implicit ctx: Context): Boolean =
       this.symbol.is(Method) && (initial.name startsWith str.ANON_FUN)
 
-    final def isAnonymousModuleVal(implicit ctx: Context) =
+    final def isAnonymousModuleVal(implicit ctx: Context): Boolean =
       this.symbol.is(ModuleVal) && (initial.name startsWith str.ANON_CLASS)
 
     /** Is this a companion class method or companion object method?
@@ -481,7 +476,7 @@ object SymDenotations {
      *  and used in SymDenotations#companionClass and
      *  SymDenotations#companionModule .
      */
-    final def isCompanionMethod(implicit ctx: Context) =
+    final def isCompanionMethod(implicit ctx: Context): Boolean =
       name.toTermName == nme.COMPANION_CLASS_METHOD ||
       name.toTermName == nme.COMPANION_MODULE_METHOD
 
@@ -489,20 +484,20 @@ object SymDenotations {
       *  These methods are generated in ExtensionMethods
       *  and used in ElimErasedValueType.
       */
-    final def isValueClassConvertMethod(implicit ctx: Context) =
+    final def isValueClassConvertMethod(implicit ctx: Context): Boolean =
       name.toTermName == nme.U2EVT ||
       name.toTermName == nme.EVT2U
 
     /** Is symbol a primitive value class? */
-    def isPrimitiveValueClass(implicit ctx: Context) =
+    def isPrimitiveValueClass(implicit ctx: Context): Boolean =
       maybeOwner == defn.ScalaPackageClass && defn.ScalaValueClasses().contains(symbol)
 
     /** Is symbol a primitive numeric value class? */
-    def isNumericValueClass(implicit ctx: Context) =
+    def isNumericValueClass(implicit ctx: Context): Boolean =
       maybeOwner == defn.ScalaPackageClass && defn.ScalaNumericValueClasses().contains(symbol)
 
     /** Is symbol a class for which no runtime representation exists? */
-    def isNotRuntimeClass(implicit ctx: Context) = defn.NotRuntimeClasses contains symbol
+    def isNotRuntimeClass(implicit ctx: Context): Boolean = defn.NotRuntimeClasses contains symbol
 
     /** Is this symbol a class representing a refinement? These classes
      *  are used only temporarily in Typer and Unpickler as an intermediate
@@ -520,16 +515,16 @@ object SymDenotations {
     }
 
     /** Is this symbol an abstract type? */
-    final def isAbstractType(implicit ctx: Context) = this is DeferredType
+    final def isAbstractType(implicit ctx: Context): Boolean = this is DeferredType
 
     /** Is this symbol an alias type? */
-    final def isAliasType(implicit ctx: Context) = isAbstractOrAliasType && !(this is Deferred)
+    final def isAliasType(implicit ctx: Context): Boolean = isAbstractOrAliasType && !(this is Deferred)
 
     /** Is this symbol an abstract or alias type? */
-    final def isAbstractOrAliasType = isType & !isClass
+    final def isAbstractOrAliasType: Boolean = isType & !isClass
 
     /** Is this symbol an abstract type or type parameter? */
-    final def isAbstractOrParamType(implicit ctx: Context) = this is DeferredOrTypeParam
+    final def isAbstractOrParamType(implicit ctx: Context): Boolean = this is DeferredOrTypeParam
 
     /** Is this the denotation of a self symbol of some class?
      *  This is the case if one of two conditions holds:
@@ -541,7 +536,7 @@ object SymDenotations {
      *  TODO: Find a more robust way to characterize self symbols, maybe by
      *       spending a Flag on them?
      */
-    final def isSelfSym(implicit ctx: Context) = owner.infoOrCompleter match {
+    final def isSelfSym(implicit ctx: Context): Boolean = owner.infoOrCompleter match {
       case ClassInfo(_, _, _, _, selfInfo) =>
         selfInfo == symbol ||
           selfInfo.isInstanceOf[Type] && name == nme.WILDCARD
@@ -564,7 +559,7 @@ object SymDenotations {
       symbol != boundary && isContainedIn(boundary)
 
     /** Is this denotation static (i.e. with no outer instance)? */
-    final def isStatic(implicit ctx: Context) =
+    final def isStatic(implicit ctx: Context): Boolean =
       (if (maybeOwner eq NoSymbol) isRoot else maybeOwner.originDenotation.isStaticOwner) ||
         myFlags.is(JavaStatic)
 
@@ -573,7 +568,7 @@ object SymDenotations {
       myFlags.is(ModuleClass) && (myFlags.is(PackageClass) || isStatic)
 
     /** Is this denotation defined in the same scope and compilation unit as that symbol? */
-    final def isCoDefinedWith(other: Symbol)(implicit ctx: Context) =
+    final def isCoDefinedWith(other: Symbol)(implicit ctx: Context): Boolean =
       (this.effectiveOwner == other.effectiveOwner) &&
       (  !(this.effectiveOwner is PackageClass)
         || this.unforcedIsAbsent || other.unforcedIsAbsent
@@ -589,13 +584,13 @@ object SymDenotations {
       )
 
     /** Is this a denotation of a stable term (or an arbitrary type)? */
-    final def isStable(implicit ctx: Context) =
+    final def isStable(implicit ctx: Context): Boolean =
       isType || is(StableOrErased) || !is(UnstableValue) && !info.isInstanceOf[ExprType]
 
     /** Is this a denotation of a class that does not have - either direct or inherited -
      *  initaliazion code?
      */
-    def isNoInitsClass(implicit ctx: Context) =
+    def isNoInitsClass(implicit ctx: Context): Boolean =
       isClass &&
       (asClass.baseClasses.forall(_.is(NoInits)) || defn.isAssuredNoInits(symbol))
 
@@ -605,53 +600,53 @@ object SymDenotations {
      *  - not an anonymous function
      *  - not a companion method
      */
-    final def isRealMethod(implicit ctx: Context) =
+    final def isRealMethod(implicit ctx: Context): Boolean =
       this.is(Method, butNot = AccessorOrLabel) &&
         !isAnonymousFunction &&
         !isCompanionMethod
 
     /** Is this a getter? */
-    final def isGetter(implicit ctx: Context) =
+    final def isGetter(implicit ctx: Context): Boolean =
       (this is Accessor) && !originalName.isSetterName && !originalName.isScala2LocalSuffix
 
     /** Is this a setter? */
-    final def isSetter(implicit ctx: Context) =
+    final def isSetter(implicit ctx: Context): Boolean =
       (this is Accessor) &&
       originalName.isSetterName &&
       (!isCompleted || info.firstParamTypes.nonEmpty) // to avoid being fooled by   var x_= : Unit = ...
 
     /** is this a symbol representing an import? */
-    final def isImport = name == nme.IMPORT
+    final def isImport: Boolean = name == nme.IMPORT
 
     /** is this the constructor of a class? */
-    final def isClassConstructor = name == nme.CONSTRUCTOR
+    final def isClassConstructor: Boolean = name == nme.CONSTRUCTOR
 
     /** Is this the constructor of a trait? */
-    final def isImplClassConstructor = name == nme.TRAIT_CONSTRUCTOR
+    final def isImplClassConstructor: Boolean = name == nme.TRAIT_CONSTRUCTOR
 
     /** Is this the constructor of a trait or a class */
-    final def isConstructor = name.isConstructorName
+    final def isConstructor: Boolean = name.isConstructorName
 
     /** Is this a local template dummmy? */
     final def isLocalDummy: Boolean = name.isLocalDummyName
 
     /** Does this symbol denote the primary constructor of its enclosing class? */
-    final def isPrimaryConstructor(implicit ctx: Context) =
+    final def isPrimaryConstructor(implicit ctx: Context): Boolean =
       isConstructor && owner.primaryConstructor == symbol
 
     /** Does this symbol denote the static constructor of its enclosing class? */
-    final def isStaticConstructor(implicit ctx: Context) =
+    final def isStaticConstructor(implicit ctx: Context): Boolean =
       name.isStaticConstructorName
 
     /** Is this a subclass of the given class `base`? */
-    def isSubClass(base: Symbol)(implicit ctx: Context) = false
+    def isSubClass(base: Symbol)(implicit ctx: Context): Boolean = false
 
     /** Is this a subclass of `base`,
      *  and is the denoting symbol also different from `Null` or `Nothing`?
      *  @note  erroneous classes are assumed to derive from all other classes
      *         and all classes derive from them.
      */
-    def derivesFrom(base: Symbol)(implicit ctx: Context) = false
+    def derivesFrom(base: Symbol)(implicit ctx: Context): Boolean = false
 
     /** Is this symbol a class that extends `AnyVal`? */
     final def isValueClass(implicit ctx: Context): Boolean = {
@@ -747,7 +742,7 @@ object SymDenotations {
     /** Do members of this symbol need translation via asSeenFrom when
      *  accessed via prefix `pre`?
      */
-    def membersNeedAsSeenFrom(pre: Type)(implicit ctx: Context) =
+    def membersNeedAsSeenFrom(pre: Type)(implicit ctx: Context): Boolean =
       !(  this.isTerm
        || this.isStaticOwner
        || ctx.erasedTypes
@@ -871,7 +866,7 @@ object SymDenotations {
       if (is(Accessor)) accessedFieldOrGetter orElse symbol else symbol
 
     /** The chain of owners of this denotation, starting with the denoting symbol itself */
-    final def ownersIterator(implicit ctx: Context) = new Iterator[Symbol] {
+    final def ownersIterator(implicit ctx: Context): Iterator[Symbol] = new Iterator[Symbol] {
       private[this] var current = symbol
       def hasNext = current.exists
       def next: Symbol = {
@@ -886,7 +881,7 @@ object SymDenotations {
       if (isWeakOwner) owner.skipWeakOwner else symbol
 
     /** The owner, skipping package objects, labels and non-lazy valdefs. */
-    final def effectiveOwner(implicit ctx: Context) = owner.skipWeakOwner
+    final def effectiveOwner(implicit ctx: Context): Symbol = owner.skipWeakOwner
 
     /** The class containing this denotation.
      *  If this denotation is already a class, return itself
@@ -1030,7 +1025,7 @@ object SymDenotations {
     /** The class that encloses the owner of the current context
      *  and that is a subclass of this class. NoSymbol if no such class exists.
      */
-    final def enclosingSubClass(implicit ctx: Context) =
+    final def enclosingSubClass(implicit ctx: Context): Symbol =
       ctx.owner.ownersIterator.findSymbol(_.isSubClass(symbol))
 
     /** The non-private symbol whose name and type matches the type of this symbol
@@ -1188,7 +1183,7 @@ object SymDenotations {
      */
     def typeParamCreationFlags: FlagSet = TypeParam
 
-    override def toString = {
+    override def toString: String = {
       val kindString =
         if (myFlags is ModuleClass) "module class"
         else if (isClass) "class"
@@ -1201,7 +1196,7 @@ object SymDenotations {
 
     // ----- Sanity checks and debugging */
 
-    def debugString = toString + "#" + symbol.id // !!! DEBUG
+    def debugString: String = toString + "#" + symbol.id // !!! DEBUG
 
     def hasSkolems(tp: Type): Boolean = tp match {
       case tp: SkolemType => true
@@ -1219,7 +1214,7 @@ object SymDenotations {
       case _ => false
     }
 
-    def assertNoSkolems(tp: Type) =
+    def assertNoSkolems(tp: Type): Unit =
       if (!this.isSkolem)
         assert(!hasSkolems(tp), s"assigning type $tp containing skolems to $this")
 
@@ -1235,7 +1230,7 @@ object SymDenotations {
       initFlags: FlagSet = UndefinedFlags,
       info: Type = null,
       privateWithin: Symbol = null,
-      annotations: List[Annotation] = null)(implicit ctx: Context) =
+      annotations: List[Annotation] = null)(implicit ctx: Context): SymDenotation =
     { // simulate default parameters, while also passing implicit context ctx to the default values
       val initFlags1 = (if (initFlags != UndefinedFlags) initFlags else this.flags)
       val info1 = if (info != null) info else this.info
@@ -1279,7 +1274,7 @@ object SymDenotations {
       super.transformAfter(phase, f)
 
     /** If denotation is private, remove the Private flag and expand the name if necessary */
-    def ensureNotPrivate(implicit ctx: Context) =
+    def ensureNotPrivate(implicit ctx: Context): SymDenotation =
       if (is(Private))
         copySymDenotation(name = expandedName, initFlags = this.flags &~ Private)
       else this
@@ -1340,7 +1335,7 @@ object SymDenotations {
       memberNamesCache = MemberNames.None
     }
 
-    def invalidateBaseTypeCache() = {
+    def invalidateBaseTypeCache(): Unit = {
       myBaseTypeCache = null
       myBaseTypeCachePeriod = Nowhere
     }
@@ -1394,7 +1389,7 @@ object SymDenotations {
       myTypeParams
     }
 
-    override protected[dotc] final def info_=(tp: Type) = {
+    override protected[dotc] final def info_=(tp: Type): Unit = {
       if (changedClassParents(infoOrCompleter, tp, completersMatter = true))
         invalidateBaseDataCache()
       invalidateMemberNamesCache()
@@ -1419,7 +1414,7 @@ object SymDenotations {
     /** The explicitly given self type (self types of modules are assumed to be
      *  explcitly given here).
      */
-    def givenSelfType(implicit ctx: Context) = classInfo.selfInfo match {
+    def givenSelfType(implicit ctx: Context): Type = classInfo.selfInfo match {
       case tp: Type => tp
       case self: Symbol => self.info
     }
@@ -1489,13 +1484,13 @@ object SymDenotations {
       || (baseClassSet contains base)
       )
 
-    final override def isSubClass(base: Symbol)(implicit ctx: Context) =
+    final override def isSubClass(base: Symbol)(implicit ctx: Context): Boolean =
       derivesFrom(base) ||
         base.isClass && (
           (symbol eq defn.NothingClass) ||
             (symbol eq defn.NullClass) && (base ne defn.NothingClass))
 
-    final override def typeParamCreationFlags = ClassTypeParamCreationFlags
+    final override def typeParamCreationFlags: FlagSet = ClassTypeParamCreationFlags
 
     /** Hook to do a pre-enter test. Overridden in PackageDenotation */
     protected def proceedWithEnter(sym: Symbol, mscope: MutableScope)(implicit ctx: Context): Boolean = true
@@ -1548,7 +1543,7 @@ object SymDenotations {
      *  Note: We require that this does not happen after the first time
      *  someone does a findMember on a subclass.
      */
-    def delete(sym: Symbol)(implicit ctx: Context) = {
+    def delete(sym: Symbol)(implicit ctx: Context): Unit = {
       info.decls.openForMutations.unlink(sym)
       if (myMemberCache != null) myMemberCache.invalidate(sym.name)
       if (!sym.flagsUNSAFE.is(Private)) invalidateMemberNamesCache()
@@ -1929,9 +1924,9 @@ object SymDenotations {
 
   @sharable object NoDenotation
   extends SymDenotation(NoSymbol, NoSymbol, "<none>".toTermName, Permanent, NoType) {
-    override def isType = false
-    override def isTerm = false
-    override def exists = false
+    override def isType: Boolean = false
+    override def isTerm: Boolean = false
+    override def exists: Boolean = false
     override def owner: Symbol = throw new AssertionError("NoDenotation.owner")
     override def computeAsSeenFrom(pre: Type)(implicit ctx: Context): SingleDenotation = this
     override def mapInfo(f: Type => Type)(implicit ctx: Context): SingleDenotation = this
@@ -1954,8 +1949,8 @@ object SymDenotations {
     /** Sets all missing fields of given denotation */
     def complete(denot: SymDenotation)(implicit ctx: Context): Unit
 
-    def apply(sym: Symbol) = this
-    def apply(module: TermSymbol, modcls: ClassSymbol) = this
+    def apply(sym: Symbol): LazyType = this
+    def apply(module: TermSymbol, modcls: ClassSymbol): LazyType = this
 
     private[this] var myDecls: Scope = EmptyScope
     private[this] var mySourceModuleFn: Context => Symbol = NoSymbolFn
@@ -1990,7 +1985,7 @@ object SymDenotations {
       unsupported("completerTypeParams") // should be abstract, but Scala-2 will then compute the wrong type for it
   }
 
-  val NoSymbolFn = (ctx: Context) => NoSymbol
+  val NoSymbolFn: Context => Symbol = (ctx: Context) => NoSymbol
 
   /** A missing completer */
   @sharable class NoCompleter extends LazyType {
@@ -2005,7 +2000,7 @@ object SymDenotations {
    *  module class, followed by copying the relevant fields to the module.
    */
   class ModuleCompleter(_moduleClass: ClassSymbol) extends LazyType {
-    override def moduleClass(implicit ctx: Context) = _moduleClass
+    override def moduleClass(implicit ctx: Context): ClassSymbol = _moduleClass
     def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
       val from = moduleClass.denot.asClass
       denot.setFlag(from.flags.toTermFlags & RetainedModuleValFlags)
@@ -2200,7 +2195,7 @@ object SymDenotations {
   }
 
   class BaseClassSet(val classIds: Array[Int]) extends AnyVal {
-    def contains(sym: Symbol, limit: Int) = {
+    def contains(sym: Symbol, limit: Int): Boolean = {
       val id = sym.id
       var i = 0
       while (i < limit && classIds(i) != id) i += 1
@@ -2253,7 +2248,7 @@ object SymDenotations {
       this
     }
 
-    def baseClassSet = {
+    def baseClassSet: BaseClassSet = {
       if (length != classIds.length) resize(length)
       new BaseClassSet(classIds)
     }
diff --git a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
index f0aed548d984..1f849ccd3e65 100644
--- a/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymbolLoaders.scala
@@ -6,16 +6,14 @@ import java.io.{IOException, File}
 import scala.compat.Platform.currentTime
 import dotty.tools.io.{ ClassPath, ClassRepresentation, AbstractFile }
 import config.Config
-import classpath._
-import Contexts._, Symbols._, Flags._, SymDenotations._, Types._, Scopes._, util.Positions._, Names._
-import StdNames._, NameOps._
+import Contexts._, Symbols._, Flags._, SymDenotations._, Types._, Scopes._, Names._
+import NameOps._
 import Decorators.{PreNamedString, StringInterpolators}
 import classfile.ClassfileParser
 import util.Stats
 import Decorators._
 import scala.util.control.NonFatal
 import ast.Trees._
-import ast.tpd
 import parsing.JavaParsers.OutlineJavaParser
 import parsing.Parsers.OutlineParser
 import reporting.trace
@@ -194,15 +192,15 @@ object SymbolLoaders {
     }
   }
 
-  def needCompile(bin: AbstractFile, src: AbstractFile) =
+  def needCompile(bin: AbstractFile, src: AbstractFile): Boolean =
     src.lastModified >= bin.lastModified
 
   /** Load contents of a package
    */
   class PackageLoader(_sourceModule: TermSymbol, classPath: ClassPath)
       extends SymbolLoader {
-    override def sourceModule(implicit ctx: Context) = _sourceModule
-    def description(implicit ctx: Context) = "package loader " + sourceModule.fullName
+    override def sourceModule(implicit ctx: Context): TermSymbol = _sourceModule
+    def description(implicit ctx: Context): String = "package loader " + sourceModule.fullName
 
     private[this] var enterFlatClasses: Option[Context => Unit] = None
 
@@ -230,22 +228,22 @@ object SymbolLoaders {
         else e
       }
 
-      override def ensureComplete()(implicit ctx: Context) =
+      override def ensureComplete()(implicit ctx: Context): Unit =
         for (enter <- enterFlatClasses) enter(ctx)
 
-      override def newScopeLikeThis() = new PackageScope
+      override def newScopeLikeThis(): PackageScope = new PackageScope
     }
 
     private[core] val currentDecls: MutableScope = new PackageScope()
 
-    def isFlatName(name: SimpleName) = name.lastIndexOf('$', name.length - 2) >= 0
+    def isFlatName(name: SimpleName): Boolean = name.lastIndexOf('$', name.length - 2) >= 0
 
-    def isFlatName(classRep: ClassRepresentation) = {
+    def isFlatName(classRep: ClassRepresentation): Boolean = {
       val idx = classRep.name.indexOf('$')
       idx >= 0 && idx < classRep.name.length - 1
     }
 
-    def maybeModuleClass(classRep: ClassRepresentation) = classRep.name.last == '$'
+    def maybeModuleClass(classRep: ClassRepresentation): Boolean = classRep.name.last == '$'
 
     private def enterClasses(root: SymDenotation, packageName: String, flat: Boolean)(implicit ctx: Context) = {
       def isAbsent(classRep: ClassRepresentation) =
@@ -370,7 +368,7 @@ class ClassfileLoader(val classfile: AbstractFile) extends SymbolLoader {
 
   override def sourceFileOrNull: AbstractFile = classfile
 
-  def description(implicit ctx: Context) = "class file " + classfile.toString
+  def description(implicit ctx: Context): String = "class file " + classfile.toString
 
   override def doComplete(root: SymDenotation)(implicit ctx: Context): Unit =
     load(root)
@@ -394,8 +392,8 @@ class ClassfileLoader(val classfile: AbstractFile) extends SymbolLoader {
 }
 
 class SourcefileLoader(val srcfile: AbstractFile) extends SymbolLoader {
-  def description(implicit ctx: Context) = "source file " + srcfile.toString
-  override def sourceFileOrNull = srcfile
+  def description(implicit ctx: Context): String = "source file " + srcfile.toString
+  override def sourceFileOrNull: AbstractFile = srcfile
   def doComplete(root: SymDenotation)(implicit ctx: Context): Unit =
     ctx.run.lateCompile(srcfile, typeCheck = ctx.settings.YretainTrees.value)
 }
diff --git a/compiler/src/dotty/tools/dotc/core/Symbols.scala b/compiler/src/dotty/tools/dotc/core/Symbols.scala
index 9bdfa4e5236d..18ac9e389ee0 100644
--- a/compiler/src/dotty/tools/dotc/core/Symbols.scala
+++ b/compiler/src/dotty/tools/dotc/core/Symbols.scala
@@ -6,7 +6,6 @@ import Periods._
 import Names._
 import Scopes._
 import Flags._
-import java.lang.AssertionError
 import Decorators._
 import Symbols._
 import Contexts._
@@ -14,7 +13,6 @@ import SymDenotations._
 import printing.Texts._
 import printing.Printer
 import Types._
-import Annotations._
 import util.Positions._
 import DenotTransformers._
 import StdNames._
@@ -25,11 +23,10 @@ import tpd.{Tree, TreeProvider, TreeOps}
 import ast.TreeTypeMap
 import Constants.Constant
 import reporting.diagnostic.Message
-import Denotations.{ Denotation, SingleDenotation, MultiDenotation }
 import collection.mutable
 import io.AbstractFile
 import language.implicitConversions
-import util.{NoSource, DotClass, Property}
+import util.{NoSource, Property}
 import scala.collection.JavaConverters._
 import scala.annotation.internal.sharable
 import config.Printers.typr
@@ -49,7 +46,7 @@ trait Symbols { this: Context =>
     new Symbol(coord, ctx.nextId).asInstanceOf[Symbol { type ThisName = N }]
 
   /** Create a class symbol without a denotation. */
-  def newNakedClassSymbol(coord: Coord = NoCoord, assocFile: AbstractFile = null)(implicit ctx: Context) =
+  def newNakedClassSymbol(coord: Coord = NoCoord, assocFile: AbstractFile = null)(implicit ctx: Context): ClassSymbol =
     new ClassSymbol(coord, assocFile, ctx.nextId)
 
 // ---- Symbol creation methods ----------------------------------
@@ -132,7 +129,7 @@ trait Symbols { this: Context =>
     newClassSymbol(owner, name, flags, completer, privateWithin, coord, assocFile)
   }
 
-  def newRefinedClassSymbol(coord: Coord = NoCoord) =
+  def newRefinedClassSymbol(coord: Coord = NoCoord): ClassSymbol =
     newCompleteClassSymbol(ctx.owner, tpnme.REFINE_CLASS, NonMember, parents = Nil, coord = coord)
 
   /** Create a module symbol with associated module class
@@ -187,9 +184,9 @@ trait Symbols { this: Context =>
           owner.thisType, modcls, parents, decls, TermRef(owner.thisType, module)),
         privateWithin, coord, assocFile)
 
-  val companionMethodFlags = Flags.Synthetic | Flags.Private | Flags.Method
+  val companionMethodFlags: FlagSet = Flags.Synthetic | Flags.Private | Flags.Method
 
-  def synthesizeCompanionMethod(name: Name, target: SymDenotation, owner: SymDenotation)(implicit ctx: Context) =
+  def synthesizeCompanionMethod(name: Name, target: SymDenotation, owner: SymDenotation)(implicit ctx: Context): Symbol =
     if (owner.exists && target.exists && !owner.unforcedIsAbsent && !target.unforcedIsAbsent) {
       val existing = owner.unforcedDecls.lookup(name)
 
@@ -224,7 +221,7 @@ 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) = {
+  def newPatternBoundSymbol(name: Name, info: Type, pos: Position): Symbol = {
     val sym = newSymbol(owner, name, Case, info, coord = pos)
     if (name.isTypeName) gadt.setBounds(sym, info.bounds)
     sym
@@ -257,7 +254,7 @@ trait Symbols { this: Context =>
    *  dummy is then the class of the template itself. By contrast, the owner of `y`
    *  would be `fld2`. There is a single local dummy per template.
    */
-  def newLocalDummy(cls: Symbol, coord: Coord = NoCoord) =
+  def newLocalDummy(cls: Symbol, coord: Coord = NoCoord): TermSymbol =
     newSymbol(cls, nme.localDummyName(cls), NonMember, NoType)
 
   /** Create an import symbol pointing back to given qualifier `expr`. */
@@ -269,15 +266,15 @@ trait Symbols { this: Context =>
     newSymbol(owner, nme.IMPORT, Synthetic | NonMember, info, coord = coord)
 
   /** Create a class constructor symbol for given class `cls`. */
-  def newConstructor(cls: ClassSymbol, flags: FlagSet, paramNames: List[TermName], paramTypes: List[Type], privateWithin: Symbol = NoSymbol, coord: Coord = NoCoord) =
+  def newConstructor(cls: ClassSymbol, flags: FlagSet, paramNames: List[TermName], paramTypes: List[Type], privateWithin: Symbol = NoSymbol, coord: Coord = NoCoord): TermSymbol =
     newSymbol(cls, nme.CONSTRUCTOR, flags | Method, MethodType(paramNames, paramTypes, cls.typeRef), privateWithin, coord)
 
   /** Create an empty default constructor symbol for given class `cls`. */
-  def newDefaultConstructor(cls: ClassSymbol) =
+  def newDefaultConstructor(cls: ClassSymbol): Symbol =
     newConstructor(cls, EmptyFlags, Nil, Nil)
 
   /** Create a synthetic lazy implicit value */
-  def newLazyImplicit(info: Type) =
+  def newLazyImplicit(info: Type): Symbol =
     newSymbol(owner, LazyImplicitName.fresh(), Lazy, info)
 
   /** Create a symbol representing a selftype declaration for class `cls`. */
@@ -311,9 +308,9 @@ 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): Symbol = newSymbol(defn.RootClass, nme.SKOLEM, SyntheticArtifact | NonMember | Permanent, tp)
 
-  def newErrorSymbol(owner: Symbol, name: Name, msg: => Message) = {
+  def newErrorSymbol(owner: Symbol, name: Name, msg: => Message): Symbol = {
     val errType = ErrorType(msg)
     newSymbol(owner, name, SyntheticArtifact,
         if (name.isTypeName) TypeAlias(errType) else errType)
@@ -407,7 +404,7 @@ object Symbols {
   implicit def eqSymbol: Eq[Symbol, Symbol] = Eq
 
   /** Tree attachment containing the identifiers in a tree as a sorted array */
-  val Ids = new Property.Key[Array[String]]
+  val Ids: Property.Key[Array[String]] = new Property.Key
 
   /** A Symbol represents a Scala definition/declaration or a package.
    *  @param coord  The coordinates of the symbol (a position or an index)
@@ -426,7 +423,7 @@ object Symbols {
      *
      *  @pre coord == NoCoord
      */
-    private[core] def coord_=(c: Coord) = {
+    private[core] def coord_=(c: Coord): Unit = {
       assert(myCoord == NoCoord)
       myCoord = c
     }
@@ -438,7 +435,7 @@ object Symbols {
       if (myDefTree == null) tpd.EmptyTree else myDefTree
 
     /** Set defining tree if this symbol retains its definition tree */
-    def defTree_=(tree: Tree)(implicit ctx: Context) =
+    def defTree_=(tree: Tree)(implicit ctx: Context): Unit =
       if (retainsDefTree) myDefTree = tree
 
     /** Does this symbol retain its definition tree?
@@ -454,10 +451,10 @@ object Symbols {
     private[this] var lastDenot: SymDenotation = _
     private[this] var checkedPeriod: Period = Nowhere
 
-    private[core] def invalidateDenotCache() = { checkedPeriod = Nowhere }
+    private[core] def invalidateDenotCache(): Unit = { checkedPeriod = Nowhere }
 
     /** Set the denotation of this symbol */
-    private[core] def denot_=(d: SymDenotation) = {
+    private[core] def denot_=(d: SymDenotation): Unit = {
       lastDenot = d
       checkedPeriod = Nowhere
     }
@@ -476,7 +473,7 @@ object Symbols {
     }
 
     /** Overridden in NoSymbol */
-    protected def recomputeDenot(lastd: SymDenotation)(implicit ctx: Context) = {
+    protected def recomputeDenot(lastd: SymDenotation)(implicit ctx: Context): SymDenotation = {
       val newd = lastd.current.asInstanceOf[SymDenotation]
       lastDenot = newd
       newd
@@ -529,13 +526,13 @@ object Symbols {
      *  conservatively returns `false` if symbol does not yet have a denotation, or denotation
      *  is a class that is not yet read.
      */
-    final def isPrivate(implicit ctx: Context) = {
+    final def isPrivate(implicit ctx: Context): Boolean = {
       val d = lastDenot
       d != null && d.flagsUNSAFE.is(Private)
     }
 
     /** The symbol's signature if it is completed or a method, NotAMethod otherwise. */
-    final def signature(implicit ctx: Context) =
+    final def signature(implicit ctx: Context): Signature =
       if (lastDenot != null && (lastDenot.isCompleted || lastDenot.is(Method)))
         denot.signature
       else
@@ -590,7 +587,7 @@ object Symbols {
       }
 
     /** This symbol, if it exists, otherwise the result of evaluating `that` */
-    def orElse(that: => Symbol)(implicit ctx: Context) =
+    def orElse(that: => Symbol)(implicit ctx: Context): Symbol =
       if (this.exists) this else that
 
     /** If this symbol satisfies predicate `p` this symbol, otherwise `NoSymbol` */
@@ -646,18 +643,18 @@ object Symbols {
     final def pos: Position = if (coord.isPosition) coord.toPosition else NoPosition
 
     // ParamInfo types and methods
-    def isTypeParam(implicit ctx: Context) = denot.is(TypeParam)
-    def paramName(implicit ctx: Context) = name.asInstanceOf[ThisName]
-    def paramInfo(implicit ctx: Context) = denot.info
-    def paramInfoAsSeenFrom(pre: Type)(implicit ctx: Context) = pre.memberInfo(this)
+    def isTypeParam(implicit ctx: Context): Boolean = denot.is(TypeParam)
+    def paramName(implicit ctx: Context): ThisName = name.asInstanceOf[ThisName]
+    def paramInfo(implicit ctx: Context): Type = denot.info
+    def paramInfoAsSeenFrom(pre: Type)(implicit ctx: Context): Type = pre.memberInfo(this)
     def paramInfoOrCompleter(implicit ctx: Context): Type = denot.infoOrCompleter
-    def paramVariance(implicit ctx: Context) = denot.variance
-    def paramRef(implicit ctx: Context) = denot.typeRef
+    def paramVariance(implicit ctx: Context): Int = denot.variance
+    def paramRef(implicit ctx: Context): TypeRef = denot.typeRef
 
 // -------- Printing --------------------------------------------------------
 
     /** The prefix string to be used when displaying this symbol without denotation */
-    protected def prefixString = "Symbol"
+    protected def prefixString: String = "Symbol"
 
     override def toString: String =
       if (lastDenot == null) s"Naked$prefixString#$id"
@@ -672,7 +669,7 @@ object Symbols {
     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.
+    override def hashCode(): Int = id // for debugging.
   }
 
   type TermSymbol = Symbol { type ThisName = TermName }
@@ -745,7 +742,7 @@ object Symbols {
     final def classDenot(implicit ctx: Context): ClassDenotation =
       denot.asInstanceOf[ClassDenotation]
 
-    override protected def prefixString = "ClassSymbol"
+    override protected def prefixString: String = "ClassSymbol"
   }
 
   @sharable object NoSymbol extends Symbol(NoCoord, 0) {
diff --git a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala b/compiler/src/dotty/tools/dotc/core/TypeApplications.scala
index e4bcea5ce191..59243d7e19eb 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeApplications.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeApplications.scala
@@ -5,28 +5,19 @@ package core
 import Types._
 import Contexts._
 import Symbols._
-import SymDenotations.{LazyType, TypeParamsCompleter}
+import SymDenotations.LazyType
 import Decorators._
 import util.Stats._
-import util.common._
 import Names._
 import NameOps._
-import NameKinds._
-import Constants.Constant
-import Flags._
-import StdNames.tpnme
-import util.Positions.Position
-import config.Printers.{core, typr}
-import collection.mutable
 import dotty.tools.dotc.config.Config
-import java.util.NoSuchElementException
 
 object TypeApplications {
 
   type TypeParamInfo = ParamInfo.Of[TypeName]
 
   /** Assert type is not a TypeBounds instance and return it unchanged */
-  def noBounds(tp: Type) = tp match {
+  def noBounds(tp: Type): Type = tp match {
     case tp: TypeBounds => throw new AssertionError("no TypeBounds allowed")
     case _ => tp
   }
@@ -59,7 +50,7 @@ object TypeApplications {
    *  @param tycon     C
    */
   object EtaExpansion {
-    def apply(tycon: Type)(implicit ctx: Context) = {
+    def apply(tycon: Type)(implicit ctx: Context): Type = {
       assert(tycon.typeParams.nonEmpty, tycon)
       tycon.EtaExpand(tycon.typeParamSymbols)
     }
@@ -113,10 +104,10 @@ object TypeApplications {
    */
   class Reducer(tycon: TypeLambda, args: List[Type])(implicit ctx: Context) extends TypeMap {
     private[this] var available = (0 until args.length).toSet
-    var allReplaced = true
-    def hasWildcardArg(p: TypeParamRef) =
+    var allReplaced: Boolean = true
+    def hasWildcardArg(p: TypeParamRef): Boolean =
       p.binder == tycon && args(p.paramNum).isInstanceOf[TypeBounds]
-    def canReduceWildcard(p: TypeParamRef) =
+    def canReduceWildcard(p: TypeParamRef): Boolean =
       !ctx.mode.is(Mode.AllowLambdaWildcardApply) || available.contains(p.paramNum)
     def atNestedLevel(op: => Type): Type = {
       val saved = available
@@ -135,7 +126,7 @@ object TypeApplications {
         atNestedLevel(apply(arg))
     }
 
-    def apply(t: Type) = t match {
+    def apply(t: Type): Type = t match {
       case t @ AppliedType(tycon, args1) if tycon.typeSymbol.isClass =>
         t.derivedAppliedType(apply(tycon), args1.mapConserve(applyArg))
       case p: TypeParamRef if p.binder == tycon =>
@@ -428,7 +419,7 @@ class TypeApplications(val self: Type) extends AnyVal {
    *  up hk type parameters matching the arguments. This is needed when unpickling
    *  Scala2 files such as `scala.collection.generic.Mapfactory`.
    */
-  final def safeAppliedTo(args: List[Type])(implicit ctx: Context) = self match {
+  final def safeAppliedTo(args: List[Type])(implicit ctx: Context): Type = self match {
     case self: TypeRef if !self.symbol.isClass && self.symbol.isCompleting =>
       AppliedType(self, args)
     case _ =>
@@ -476,13 +467,13 @@ class TypeApplications(val self: Type) extends AnyVal {
   }
 
   /** Argument types where existential types in arguments are disallowed */
-  def argTypes(implicit ctx: Context) = argInfos mapConserve noBounds
+  def argTypes(implicit ctx: Context): List[Type] = argInfos mapConserve noBounds
 
   /** Argument types where existential types in arguments are approximated by their lower bound */
-  def argTypesLo(implicit ctx: Context) = argInfos.mapConserve(_.loBound)
+  def argTypesLo(implicit ctx: Context): List[Type] = argInfos.mapConserve(_.loBound)
 
   /** Argument types where existential types in arguments are approximated by their upper bound  */
-  def argTypesHi(implicit ctx: Context) = argInfos.mapConserve(_.hiBound)
+  def argTypesHi(implicit ctx: Context): List[Type] = argInfos.mapConserve(_.hiBound)
 
   /** If this is the image of a type argument; recover the type argument,
    *  otherwise NoType.
diff --git a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
index 38d164301cd2..e3fa098586ac 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeComparer.scala
@@ -4,11 +4,11 @@ package core
 
 import Types._, Contexts._, Symbols._, Flags._, Names._, NameOps._, Denotations._
 import Decorators._
-import StdNames.{nme, tpnme}
+import StdNames.nme
 import collection.mutable
-import util.{Stats, DotClass}
+import util.Stats
 import config.Config
-import config.Printers.{typr, constr, subtyping, gadts, noPrinter}
+import config.Printers.{constr, subtyping, gadts, noPrinter}
 import TypeErasure.{erasedLub, erasedGlb}
 import TypeApplications._
 import Constants.Constant
@@ -21,9 +21,9 @@ import reporting.trace
  */
 class TypeComparer(initctx: Context) extends ConstraintHandling {
   import TypeComparer._
-  implicit val ctx = initctx
+  implicit val ctx: Context = initctx
 
-  val state = ctx.typerState
+  val state: TyperState = ctx.typerState
   import state.constraint
 
   private[this] var pendingSubTypes: mutable.Set[(Type, Type)] = null
@@ -59,41 +59,41 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
   private[this] var myAnyKindType: TypeRef = null
   private[this] var myNothingType: TypeRef = null
 
-  def AnyClass = {
+  def AnyClass: ClassSymbol = {
     if (myAnyClass == null) myAnyClass = defn.AnyClass
     myAnyClass
   }
-  def AnyKindClass = {
+  def AnyKindClass: ClassSymbol = {
     if (myAnyKindClass == null) myAnyKindClass = defn.AnyKindClass
     myAnyKindClass
   }
-  def NothingClass = {
+  def NothingClass: ClassSymbol = {
     if (myNothingClass == null) myNothingClass = defn.NothingClass
     myNothingClass
   }
-  def NullClass = {
+  def NullClass: ClassSymbol = {
     if (myNullClass == null) myNullClass = defn.NullClass
     myNullClass
   }
-  def ObjectClass = {
+  def ObjectClass: ClassSymbol = {
     if (myObjectClass == null) myObjectClass = defn.ObjectClass
     myObjectClass
   }
-  def AnyType = {
+  def AnyType: TypeRef = {
     if (myAnyType == null) myAnyType = AnyClass.typeRef
     myAnyType
   }
-  def AnyKindType = {
+  def AnyKindType: TypeRef = {
     if (myAnyKindType == null) myAnyKindType = AnyKindClass.typeRef
     myAnyKindType
   }
-  def NothingType = {
+  def NothingType: TypeRef = {
     if (myNothingType == null) myNothingType = NothingClass.typeRef
     myNothingType
   }
 
   /** Indicates whether a previous subtype check used GADT bounds */
-  var GADTused = false
+  var GADTused: Boolean = false
 
   /** Record that GADT bounds of `sym` were used in a subtype check.
    *  But exclude constructor type parameters, as these are aliased
@@ -105,10 +105,10 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
     true
   }
 
-  protected def gadtBounds(sym: Symbol)(implicit ctx: Context) = ctx.gadt.bounds(sym)
-  protected def gadtSetBounds(sym: Symbol, b: TypeBounds) = ctx.gadt.setBounds(sym, b)
+  protected def gadtBounds(sym: Symbol)(implicit ctx: Context): TypeBounds = ctx.gadt.bounds(sym)
+  protected def gadtSetBounds(sym: Symbol, b: TypeBounds): Unit = ctx.gadt.setBounds(sym, b)
 
-  protected def typeVarInstance(tvar: TypeVar)(implicit ctx: Context) = tvar.underlying
+  protected def typeVarInstance(tvar: TypeVar)(implicit ctx: Context): Type = tvar.underlying
 
   // Subtype testing `<:<`
 
@@ -124,7 +124,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
   }
 
   private[this] var approx: ApproxState = NoApprox
-  protected def approxState = approx
+  protected def approxState: ApproxState = approx
 
   protected def isSubType(tp1: Type, tp2: Type, a: ApproxState): Boolean = {
     val saved = approx
@@ -1196,7 +1196,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
   }
 
   /** Defer constraining type variables when compared against prototypes */
-  def isMatchedByProto(proto: ProtoType, tp: Type) = tp.stripTypeVar match {
+  def isMatchedByProto(proto: ProtoType, tp: Type): Boolean = tp.stripTypeVar match {
     case tp: TypeParamRef if constraint contains tp => true
     case _ => proto.isMatchedBy(tp)
   }
@@ -1556,7 +1556,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
    *
    *  In these cases, a MergeError is thrown.
    */
-  final def andType(tp1: Type, tp2: Type, isErased: Boolean = ctx.erasedTypes) = trace(s"glb(${tp1.show}, ${tp2.show})", subtyping, show = true) {
+  final def andType(tp1: Type, tp2: Type, isErased: Boolean = ctx.erasedTypes): Type = trace(s"glb(${tp1.show}, ${tp2.show})", subtyping, show = true) {
     val t1 = distributeAnd(tp1, tp2)
     if (t1.exists) t1
     else {
@@ -1580,7 +1580,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
    *  @param isErased Apply erasure semantics. If erased is true, instead of creating
    *                  an OrType, the lub will be computed using TypeCreator#erasedLub.
    */
-  final def orType(tp1: Type, tp2: Type, isErased: Boolean = ctx.erasedTypes) = {
+  final def orType(tp1: Type, tp2: Type, isErased: Boolean = ctx.erasedTypes): Type = {
     val t1 = distributeOr(tp1, tp2)
     if (t1.exists) t1
     else {
@@ -1719,7 +1719,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
   }
 
   /** A new type comparer of the same type as this one, using the given context. */
-  def copyIn(ctx: Context) = new TypeComparer(ctx)
+  def copyIn(ctx: Context): TypeComparer = new TypeComparer(ctx)
 
   // ----------- Diagnostics --------------------------------------------------
 
@@ -1737,7 +1737,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
     }
 
   /** Show subtype goal that led to an assertion failure */
-  def showGoal(tp1: Type, tp2: Type)(implicit ctx: Context) = {
+  def showGoal(tp1: Type, tp2: Type)(implicit ctx: Context): Unit = {
     println(i"assertion failure for ${show(tp1)} <:< ${show(tp2)}, frozen = $frozenConstraint")
     def explainPoly(tp: Type) = tp match {
       case tp: TypeParamRef => ctx.echo(s"TypeParamRef ${tp.show} found in ${tp.binder.show}")
@@ -1755,7 +1755,7 @@ class TypeComparer(initctx: Context) extends ConstraintHandling {
    *  and the number of "successful" subtype checks, i.e. checks
    *  that form part of a subtype derivation tree that's ultimately successful.
    */
-  def recordStatistics(result: Boolean, prevSuccessCount: Int) = {
+  def recordStatistics(result: Boolean, prevSuccessCount: Int): Unit = {
     // Stats.record(s"isSubType ${tp1.show} <:< ${tp2.show}")
     totalCount += 1
     if (result) successCount += 1 else successCount = prevSuccessCount
@@ -1775,7 +1775,7 @@ object TypeComparer {
     var tpe: Type = NoType
   }
 
-  private[core] def show(res: Any)(implicit ctx: Context) = res match {
+  private[core] def show(res: Any)(implicit ctx: Context): String = res match {
     case res: printing.Showable if !ctx.settings.YexplainLowlevel.value => res.show
     case _ => String.valueOf(res)
   }
@@ -1784,18 +1784,18 @@ object TypeComparer {
   private val HiApprox = 2
 
   class ApproxState(private val bits: Int) extends AnyVal {
-    override def toString = {
+    override def toString: String = {
       val lo = if ((bits & LoApprox) != 0) "LoApprox" else ""
       val hi = if ((bits & HiApprox) != 0) "HiApprox" else ""
       lo ++ hi
     }
-    def addLow = new ApproxState(bits | LoApprox)
-    def addHigh = new ApproxState(bits | HiApprox)
-    def low = (bits & LoApprox) != 0
-    def high = (bits & HiApprox) != 0
+    def addLow: ApproxState = new ApproxState(bits | LoApprox)
+    def addHigh: ApproxState = new ApproxState(bits | HiApprox)
+    def low: Boolean = (bits & LoApprox) != 0
+    def high: Boolean = (bits & HiApprox) != 0
   }
 
-  val NoApprox = new ApproxState(0)
+  val NoApprox: ApproxState = new ApproxState(0)
 
   /** Show trace of comparison operations when performing `op` as result string */
   def explained[T](op: Context => T)(implicit ctx: Context): String = {
@@ -1808,7 +1808,7 @@ object TypeComparer {
 class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
   import state.constraint
 
-  val footprint = mutable.Set[Type]()
+  val footprint: mutable.Set[Type] = mutable.Set[Type]()
 
   override def bounds(param: TypeParamRef): TypeBounds = {
     if (param.binder `ne` caseLambda) footprint += param
@@ -1820,17 +1820,17 @@ class TrackingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
     super.addOneBound(param, bound, isUpper)
   }
 
-  override def gadtBounds(sym: Symbol)(implicit ctx: Context) = {
+  override def gadtBounds(sym: Symbol)(implicit ctx: Context): TypeBounds = {
     footprint += sym.typeRef
     super.gadtBounds(sym)
   }
 
-  override def gadtSetBounds(sym: Symbol, b: TypeBounds) = {
+  override def gadtSetBounds(sym: Symbol, b: TypeBounds): Unit = {
     footprint += sym.typeRef
     super.gadtSetBounds(sym, b)
   }
 
-  override def typeVarInstance(tvar: TypeVar)(implicit ctx: Context) = {
+  override def typeVarInstance(tvar: TypeVar)(implicit ctx: Context): Type = {
     footprint += tvar
     super.typeVarInstance(tvar)
   }
@@ -1901,7 +1901,7 @@ class ExplainingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
       res
     }
 
-  override def isSubType(tp1: Type, tp2: Type, approx: ApproxState) =
+  override def isSubType(tp1: Type, tp2: Type, approx: ApproxState): Boolean =
     traceIndented(s"${show(tp1)} <:< ${show(tp2)}${if (Config.verboseExplainSubtype) s" ${tp1.getClass} ${tp2.getClass}" else ""} $approx ${if (frozenConstraint) " frozen" else ""}") {
       super.isSubType(tp1, tp2, approx)
     }
@@ -1911,12 +1911,12 @@ class ExplainingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
       super.hasMatchingMember(name, tp1, tp2)
     }
 
-  override def lub(tp1: Type, tp2: Type, canConstrain: Boolean = false) =
+  override def lub(tp1: Type, tp2: Type, canConstrain: Boolean = false): Type =
     traceIndented(s"lub(${show(tp1)}, ${show(tp2)}, canConstrain=$canConstrain)") {
       super.lub(tp1, tp2, canConstrain)
     }
 
-  override def glb(tp1: Type, tp2: Type) =
+  override def glb(tp1: Type, tp2: Type): Type =
     traceIndented(s"glb(${show(tp1)}, ${show(tp2)})") {
       super.glb(tp1, tp2)
     }
@@ -1926,7 +1926,7 @@ class ExplainingTypeComparer(initctx: Context) extends TypeComparer(initctx) {
       super.addConstraint(param, bound, fromBelow)
     }
 
-  override def copyIn(ctx: Context) = new ExplainingTypeComparer(ctx)
+  override def copyIn(ctx: Context): ExplainingTypeComparer = new ExplainingTypeComparer(ctx)
 
-  override def toString = "Subtype trace:" + { try b.toString finally b.clear() }
+  override def toString: String = "Subtype trace:" + { try b.toString finally b.clear() }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
index 4063eddf4a55..27b19c084913 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -2,13 +2,11 @@ package dotty.tools
 package dotc
 package core
 
-import Symbols._, Types._, Contexts._, Flags._, Names._, StdNames._, Decorators._
+import Symbols._, Types._, Contexts._, Flags._, Names._, StdNames._
 import Flags.JavaDefined
-import NameOps._
 import Uniques.unique
 import dotc.transform.ExplicitOuter._
 import dotc.transform.ValueClasses._
-import util.DotClass
 import transform.TypeUtils._
 import Definitions.MaxImplementedFunctionArity
 import scala.annotation.tailrec
@@ -83,14 +81,14 @@ object TypeErasure {
    */
   abstract case class ErasedValueType(tycon: TypeRef, erasedUnderlying: Type)
   extends CachedGroundType with ValueType {
-    override def computeHash(bs: Hashable.Binders) = doHash(bs, tycon, erasedUnderlying)
+    override def computeHash(bs: Hashable.Binders): Int = doHash(bs, tycon, erasedUnderlying)
   }
 
   final class CachedErasedValueType(tycon: TypeRef, erasedUnderlying: Type)
     extends ErasedValueType(tycon, erasedUnderlying)
 
   object ErasedValueType {
-    def apply(tycon: TypeRef, erasedUnderlying: Type)(implicit ctx: Context) = {
+    def apply(tycon: TypeRef, erasedUnderlying: Type)(implicit ctx: Context): ErasedValueType = {
       assert(erasedUnderlying.exists)
       unique(new CachedErasedValueType(tycon, erasedUnderlying))
     }
@@ -469,7 +467,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
    *  `PolyType`s are treated. `eraseInfo` maps them them to method types, whereas `apply` maps them
    *  to the underlying type.
    */
-  def eraseInfo(tp: Type, sym: Symbol)(implicit ctx: Context) = tp match {
+  def eraseInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = tp match {
     case ExprType(rt) =>
       if (sym is Param) apply(tp)
         // Note that params with ExprTypes are eliminated by ElimByName,
diff --git a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
index bafa67943887..9dd987779843 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErrors.scala
@@ -2,7 +2,6 @@ package dotty.tools
 package dotc
 package core
 
-import util.common._
 import Types._
 import Symbols._
 import Flags._
@@ -42,7 +41,7 @@ class MissingType(pre: Type, name: Name) extends TypeError {
 
 class RecursionOverflow(val op: String, details: => String, previous: Throwable, val weight: Int) extends TypeError {
 
-  def explanation = s"$op $details"
+  def explanation: String = s"$op $details"
 
   private def recursions: List[RecursionOverflow] = {
     val nested = previous match {
@@ -72,7 +71,7 @@ class RecursionOverflow(val op: String, details: => String, previous: Throwable,
   }
 
   override def fillInStackTrace(): Throwable = this
-  override def getStackTrace() = previous.getStackTrace()
+  override def getStackTrace(): Array[StackTraceElement] = previous.getStackTrace()
 }
 
 /** Post-process exceptions that might result from StackOverflow to add
@@ -169,7 +168,7 @@ class MergeError(val sym1: Symbol, val sym2: Symbol, val tp1: Type, val tp2: Typ
     case _ => tp.show
   }
 
-  protected def addendum(implicit ctx: Context) =
+  protected def addendum(implicit ctx: Context): String =
     if (prefix `eq` NoPrefix) "" else i"\nas members of type $prefix"
 
   override def toMessage(implicit ctx: Context): Message = {
diff --git a/compiler/src/dotty/tools/dotc/core/TypeOps.scala b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
index a839fe3502c8..1677649d49ff 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeOps.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeOps.scala
@@ -2,18 +2,12 @@ package dotty.tools
 package dotc
 package core
 
-import Contexts._, Types._, Symbols._, Names._, Flags._, Scopes._
-import SymDenotations._, Denotations.SingleDenotation
-import config.Printers.typr
+import Contexts._, Types._, Symbols._, Names._, Flags._
+import SymDenotations._
 import util.Positions._
-import NameOps._
 import NameKinds.DepParamName
 import Decorators._
 import StdNames._
-import Annotations._
-import annotation.tailrec
-import config.Config
-import util.Property
 import collection.mutable
 import ast.tpd._
 import reporting.trace
@@ -71,7 +65,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
       }
     }
 
-    override def reapply(tp: Type) =
+    override def reapply(tp: Type): Type =
       // derived infos have already been subjected to asSeenFrom, hence to need to apply the map again.
       tp
   }
@@ -118,7 +112,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
   }
 
   class SimplifyMap extends TypeMap {
-    def apply(tp: Type) = simplify(tp, this)
+    def apply(tp: Type): Type = simplify(tp, this)
   }
 
   /** Approximate union type by intersection of its dominators.
@@ -280,7 +274,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
   }
 
   /** Are we in an inline method body? */
-  def inInlineMethod = owner.ownersIterator.exists(_.isInlineMethod)
+  def inInlineMethod: Boolean = owner.ownersIterator.exists(_.isInlineMethod)
 
   /** Is `feature` enabled in class `owner`?
    *  This is the case if one of the following two alternatives holds:
@@ -317,16 +311,16 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
   }
 
   /** Is auto-tupling enabled? */
-  def canAutoTuple =
+  def canAutoTuple: Boolean =
     !featureEnabled(defn.LanguageModuleClass, nme.noAutoTupling)
 
-  def scala2Mode =
+  def scala2Mode: Boolean =
     featureEnabled(defn.LanguageModuleClass, nme.Scala2)
 
-  def dynamicsEnabled =
+  def dynamicsEnabled: Boolean =
     featureEnabled(defn.LanguageModuleClass, nme.dynamics)
 
-  def testScala2Mode(msg: => Message, pos: Position, replace: => Unit = ()) = {
+  def testScala2Mode(msg: => Message, pos: Position, replace: => Unit = ()): Boolean = {
     if (scala2Mode) {
       migrationWarning(msg, pos)
       replace
@@ -336,5 +330,5 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
 }
 
 object TypeOps {
-  @sharable var track = false // !!!DEBUG
+  @sharable var track: Boolean = false // !!!DEBUG
 }
diff --git a/compiler/src/dotty/tools/dotc/core/TyperState.scala b/compiler/src/dotty/tools/dotc/core/TyperState.scala
index d176e5eddd99..5a2fb0052e0d 100644
--- a/compiler/src/dotty/tools/dotc/core/TyperState.scala
+++ b/compiler/src/dotty/tools/dotc/core/TyperState.scala
@@ -3,16 +3,12 @@ package dotc
 package core
 
 import Types._
-import Flags._
 import Contexts._
-import util.{SimpleIdentityMap, SimpleIdentitySet, DotClass}
+import util.{SimpleIdentityMap, SimpleIdentitySet}
 import reporting._
-import printing.{Showable, Printer}
-import printing.Texts._
 import config.Config
 import collection.mutable
 import java.lang.ref.WeakReference
-import Decorators._
 
 import scala.annotation.internal.sharable
 
@@ -22,7 +18,7 @@ object TyperState {
 
 class TyperState(previous: TyperState /* | Null */) {
 
-  val id = TyperState.nextId
+  val id: Int = TyperState.nextId
   TyperState.nextId += 1
 
   private[this] var myReporter =
@@ -37,14 +33,14 @@ class TyperState(previous: TyperState /* | Null */) {
     if (previous == null) new OrderingConstraint(SimpleIdentityMap.Empty, SimpleIdentityMap.Empty, SimpleIdentityMap.Empty)
     else previous.constraint
 
-  def constraint = myConstraint
-  def constraint_=(c: Constraint)(implicit ctx: Context) = {
+  def constraint: Constraint = myConstraint
+  def constraint_=(c: Constraint)(implicit ctx: Context): Unit = {
     if (Config.debugCheckConstraintsClosed && isGlobalCommittable) c.checkClosed()
     myConstraint = c
   }
 
   /** Reset constraint to `c` and mark current constraint as retracted if it differs from `c` */
-  def resetConstraintTo(c: Constraint) = {
+  def resetConstraintTo(c: Constraint): Unit = {
     if (c `ne` myConstraint) myConstraint.markRetracted()
     myConstraint = c
   }
@@ -54,7 +50,7 @@ class TyperState(previous: TyperState /* | Null */) {
 
   private[this] var myIsCommittable = true
 
-  def isCommittable = myIsCommittable
+  def isCommittable: Boolean = myIsCommittable
 
   def setCommittable(committable: Boolean): this.type = { this.myIsCommittable = committable; this }
 
@@ -76,11 +72,11 @@ class TyperState(previous: TyperState /* | Null */) {
     new TyperState(this).setReporter(new StoreReporter(reporter)).setCommittable(isCommittable)
 
   /** The uninstantiated variables */
-  def uninstVars = constraint.uninstVars
+  def uninstVars: Seq[TypeVar] = constraint.uninstVars
 
   /** The set of uninstantiated type variables which have this state as their owning state */
   private[this] var myOwnedVars: TypeVars = SimpleIdentitySet.empty
-  def ownedVars = myOwnedVars
+  def ownedVars: TypeVars = myOwnedVars
   def ownedVars_=(vs: TypeVars): Unit = myOwnedVars = vs
 
   /** Gives for each instantiated type var that does not yet have its `inst` field
@@ -154,7 +150,7 @@ class TyperState(previous: TyperState /* | Null */) {
    * isApplicableSafe but also for (e.g. erased-lubs.scala) as well as
    * many parts of dotty itself.
    */
-  def commit()(implicit ctx: Context) = {
+  def commit()(implicit ctx: Context): Unit = {
     val targetState = ctx.typerState
     assert(isCommittable)
     targetState.constraint =
@@ -197,9 +193,9 @@ class TyperState(previous: TyperState /* | Null */) {
 /** Temporary, reusable reporter used in TyperState#test */
 private class TestReporter(outer: Reporter) extends StoreReporter(outer) {
   /** Is this reporter currently used in a test? */
-  var inUse = false
+  var inUse: Boolean = false
 
-  def reset() = {
+  def reset(): Unit = {
     assert(!inUse, s"Cannot reset reporter currently in use: $this")
     infos = null
   }
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index c4aebabf1329..6af06094cf42 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -7,7 +7,7 @@ import Symbols._
 import Flags._
 import Names._
 import StdNames._, NameOps._
-import NameKinds.{SkolemName, SignedName}
+import NameKinds.SkolemName
 import Scopes._
 import Constants._
 import Contexts._
@@ -16,15 +16,12 @@ import SymDenotations._
 import Decorators._
 import Denotations._
 import Periods._
-import util.Positions.{Position, NoPosition}
 import util.Stats._
-import util.{DotClass, SimpleIdentitySet}
+import util.SimpleIdentitySet
 import reporting.diagnostic.Message
 import ast.tpd._
 import ast.TreeTypeMap
 import printing.Texts._
-import ast.untpd
-import dotty.tools.dotc.transform.Erasure
 import printing.Printer
 import Hashable._
 import Uniques._
@@ -105,7 +102,7 @@ object Types {
      *  uninstantiated type variables or type symbols that have the Provisional flag set.
      *  This is an antimonotonic property - once a type is not provisional, it stays so forever.
      */
-    def isProvisional(implicit ctx: Context) = mightBeProvisional && testProvisional
+    def isProvisional(implicit ctx: Context): Boolean = mightBeProvisional && testProvisional
 
     private def testProvisional(implicit ctx: Context) = {
       val accu = new TypeAccumulator[Boolean] {
@@ -139,7 +136,7 @@ object Types {
     final def exists: Boolean = this.ne(NoType)
 
     /** This type, if it exists, otherwise `that` type */
-    def orElse(that: => Type) = if (exists) this else that
+    def orElse(that: => Type): Type = if (exists) this else that
 
     /** Is this type a value type? */
     final def isValueType: Boolean = this.isInstanceOf[ValueType]
@@ -231,7 +228,7 @@ object Types {
      *  `<this> . <symd>` is an actual argument reference, i.e. `this` is different
      *  from the ThisType of `symd`'s owner.
      */
-    def isArgPrefixOf(symd: SymDenotation)(implicit ctx: Context) =
+    def isArgPrefixOf(symd: SymDenotation)(implicit ctx: Context): Boolean =
       symd.is(ClassTypeParam) && {
         this match {
           case tp: ThisType => tp.cls ne symd.owner
@@ -252,7 +249,7 @@ object Types {
     }
 
     /** Is this type a (possibly aliased) singleton type? */
-    def isSingleton(implicit ctx: Context) = dealias.isInstanceOf[SingletonType]
+    def isSingleton(implicit ctx: Context): Boolean = dealias.isInstanceOf[SingletonType]
 
     /** Is this type of kind `AnyKind`? */
     def hasAnyKind(implicit ctx: Context): Boolean = {
@@ -842,7 +839,7 @@ object Types {
     }
 
     /** Is this type a primitive value type which can be widened to the primitive value type `that`? */
-    def isValueSubType(that: Type)(implicit ctx: Context) = widen match {
+    def isValueSubType(that: Type)(implicit ctx: Context): Boolean = widen match {
       case self: TypeRef if self.symbol.isPrimitiveValueClass =>
         that.widenExpr match {
           case that: TypeRef if that.symbol.isPrimitiveValueClass =>
@@ -854,7 +851,7 @@ object Types {
         false
     }
 
-    def relaxed_<:<(that: Type)(implicit ctx: Context) =
+    def relaxed_<:<(that: Type)(implicit ctx: Context): Boolean =
       (this <:< that) || (this isValueSubType that)
 
     /** Is this type a legal type for member `sym1` that overrides another
@@ -1089,7 +1086,7 @@ object Types {
     /** The result of normalization using `tryNormalize`, or the type itself if
      *  tryNormlize yields NoType
      */
-    final def normalized(implicit ctx: Context) = {
+    final def normalized(implicit ctx: Context): Type = {
       val normed = tryNormalize
       if (normed.exists) normed else this
     }
@@ -1178,7 +1175,7 @@ object Types {
     /** Useful for diagnostics: The underlying type if this type is a type proxy,
      *  otherwise NoType
      */
-    def underlyingIfProxy(implicit ctx: Context) = this match {
+    def underlyingIfProxy(implicit ctx: Context): Type = this match {
       case this1: TypeProxy => this1.underlying
       case _ => NoType
     }
@@ -1347,13 +1344,13 @@ object Types {
     }
 
     /** The lower bound of a TypeBounds type, the type itself otherwise */
-    def loBound = this match {
+    def loBound: Type = this match {
       case tp: TypeBounds => tp.lo
       case _ => this
     }
 
     /** The upper bound of a TypeBounds type, the type itself otherwise */
-    def hiBound = this match {
+    def hiBound: Type = this match {
       case tp: TypeBounds => tp.hi
       case _ => this
     }
@@ -1473,7 +1470,7 @@ object Types {
      *  after the type variables are instantiated. Finally, it
      *  maps poly params in the current constraint set back to their type vars.
      */
-    def simplified(implicit ctx: Context) = ctx.simplify(this, null)
+    def simplified(implicit ctx: Context): Type = ctx.simplify(this, null)
 
     /** Compare `this == that`, assuming corresponding binders in `bs` are equal.
      *  The normal `equals` should be equivalent to `equals(that, null`)`.
@@ -1539,35 +1536,35 @@ object Types {
   /**  Instances of this class are cached and are not proxies. */
   abstract class CachedGroundType extends Type with CachedType {
     private[this] var myHash = HashUnknown
-    final def hash = {
+    final def hash: Int = {
       if (myHash == HashUnknown) {
         myHash = computeHash(null)
         assert(myHash != HashUnknown)
       }
       myHash
     }
-    override final def hashCode =
+    override final def hashCode: Int =
       if (hash == NotCached) System.identityHashCode(this) else hash
   }
 
   /**  Instances of this class are cached and are proxies. */
   abstract class CachedProxyType extends TypeProxy with CachedType {
-    protected[this] var myHash = HashUnknown
-    final def hash = {
+    protected[this] var myHash: Int = HashUnknown
+    final def hash: Int = {
       if (myHash == HashUnknown) {
         myHash = computeHash(null)
         assert(myHash != HashUnknown)
       }
       myHash
     }
-    override final def hashCode =
+    override final def hashCode: Int =
       if (hash == NotCached) System.identityHashCode(this) else hash
   }
 
   /**  Instances of this class are uncached and are not proxies. */
   abstract class UncachedGroundType extends Type {
-    final def hash = NotCached
-    final def computeHash(bs: Binders) = NotCached
+    final def hash: Int = NotCached
+    final def computeHash(bs: Binders): Int = NotCached
     if (monitored) {
       record(s"uncachable")
       record(s"uncachable: $getClass")
@@ -1576,8 +1573,8 @@ object Types {
 
   /**  Instances of this class are uncached and are proxies. */
   abstract class UncachedProxyType extends TypeProxy {
-    final def hash = NotCached
-    final def computeHash(bs: Binders) = NotCached
+    final def hash: Int = NotCached
+    final def computeHash(bs: Binders): Int = NotCached
     if (monitored) {
       record(s"uncachable")
       record(s"uncachable: $getClass")
@@ -1602,7 +1599,7 @@ object Types {
    *  single non-null value (they might contain null in addition).
    */
   trait SingletonType extends TypeProxy with ValueType {
-    def isOverloaded(implicit ctx: Context) = false
+    def isOverloaded(implicit ctx: Context): Boolean = false
   }
 
   /** A trait for types that bind other types that refer to them.
@@ -1613,7 +1610,7 @@ object Types {
     /** If this type is in `bs`, a hashcode based on its position in `bs`.
      *  Otherise the standard identity hash.
      */
-    override def identityHash(bs: Binders) = {
+    override def identityHash(bs: Binders): Int = {
       def recur(n: Int, tp: BindingType, rest: Binders): Int =
         if (this `eq` tp) finishHash(hashing.mix(hashSeed, n), 1)
         else if (rest == null) System.identityHashCode(this)
@@ -1672,8 +1669,8 @@ object Types {
     // (2) lastDenotation != null    =>  lastSymbol != null
     // (3) mySigRunId != NoRunId     =>  mySig != null
 
-    def isType = isInstanceOf[TypeRef]
-    def isTerm = isInstanceOf[TermRef]
+    def isType: Boolean = isInstanceOf[TypeRef]
+    def isTerm: Boolean = isInstanceOf[TermRef]
 
     /** If designator is a name, this name. Otherwise, the original name
      *  of the designator symbol.
@@ -1729,7 +1726,7 @@ object Types {
     /** There is a denotation computed which is valid (somewhere in) the
      *  current run.
      */
-    def denotationIsCurrent(implicit ctx: Context) =
+    def denotationIsCurrent(implicit ctx: Context): Boolean =
       lastDenotation != null && lastDenotation.validFor.runId == ctx.runId
 
     /** If the reference is symbolic or the denotation is current, its symbol, otherwise NoDenotation.
@@ -1741,7 +1738,7 @@ object Types {
      *  type accumulators, as well as to be safe in diagnostic printing.
      *  Normally, it's better to use `symbol`, not `currentSymbol`.
      */
-    final def currentSymbol(implicit ctx: Context) = designator match {
+    final def currentSymbol(implicit ctx: Context): Symbol = designator match {
       case sym: Symbol => sym
       case _ => if (denotationIsCurrent) lastDenotation.symbol else NoSymbol
     }
@@ -1885,7 +1882,7 @@ object Types {
     /** Reload denotation by computing the member with the reference's name as seen
      *  from the reference's prefix.
      */
-    def recomputeDenot()(implicit ctx: Context) =
+    def recomputeDenot()(implicit ctx: Context): Unit =
       setDenot(memberDenot(name, allowPrivate = !symbol.exists || symbol.is(Private)))
 
     private def setDenot(denot: Denotation)(implicit ctx: Context): Unit = {
@@ -1944,7 +1941,7 @@ object Types {
       symd.maybeOwner.membersNeedAsSeenFrom(prefix) && !symd.is(NonMember)
 
     /** Is this a reference to a class or object member? */
-    def isMemberRef(implicit ctx: Context) = designator match {
+    def isMemberRef(implicit ctx: Context): Boolean = designator match {
       case sym: Symbol => infoDependsOnPrefix(sym, prefix)
       case _ => true
     }
@@ -2117,7 +2114,7 @@ object Types {
       }
     }
 
-    override def equals(that: Any) = equals(that, null)
+    override def equals(that: Any): Boolean = equals(that, null)
 
     override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: NamedType =>
@@ -2127,14 +2124,14 @@ object Types {
         false
     }
 
-    override def computeHash(bs: Binders) = doHash(bs, designator, prefix)
+    override def computeHash(bs: Binders): Int = doHash(bs, designator, prefix)
 
-    override def stableHash = {
+    override def stableHash: Boolean = {
       if (myStableHash == 0) myStableHash = if (prefix.stableHash) 1 else -1
       myStableHash > 0
     }
 
-    override def eql(that: Type) = this eq that // safe because named types are hash-consed separately
+    override def eql(that: Type): Boolean = this eq that // safe because named types are hash-consed separately
   }
 
   /** A reference to an implicit definition. This can be either a TermRef or a
@@ -2152,8 +2149,8 @@ object Types {
     type ThisType = TermRef
     type ThisName = TermName
 
-    override def designator = myDesignator
-    override protected def designator_=(d: Designator) = myDesignator = d
+    override def designator: Designator = myDesignator
+    override protected def designator_=(d: Designator): Unit = myDesignator = d
 
     //assert(name.toString != "<local Coder>")
     override def underlying(implicit ctx: Context): Type = {
@@ -2161,7 +2158,7 @@ object Types {
       if (d.isOverloaded) NoType else d.info
     }
 
-    override def isOverloaded(implicit ctx: Context) = denot.isOverloaded
+    override def isOverloaded(implicit ctx: Context): Boolean = denot.isOverloaded
 
     def alternatives(implicit ctx: Context): List[TermRef] =
       denot.alternatives.map(withDenot(_))
@@ -2170,7 +2167,7 @@ object Types {
       denot.altsWith(p).map(withDenot(_))
 
     def implicitName(implicit ctx: Context): TermName = name
-    def underlyingRef = this
+    def underlyingRef: TermRef = this
   }
 
   abstract case class TypeRef(override val prefix: Type,
@@ -2180,8 +2177,8 @@ object Types {
     type ThisType = TypeRef
     type ThisName = TypeName
 
-    override def designator = myDesignator
-    override protected def designator_=(d: Designator) = myDesignator = d
+    override def designator: Designator = myDesignator
+    override protected def designator_=(d: Designator): Unit = myDesignator = d
 
     override def underlying(implicit ctx: Context): Type = info
   }
@@ -2201,14 +2198,14 @@ object Types {
     if (Config.checkUnerased) assert(!ctx.phase.erasedTypes)
 
   object NamedType {
-    def isType(desig: Designator)(implicit ctx: Context) = desig match {
+    def isType(desig: Designator)(implicit ctx: Context): Boolean = desig match {
       case sym: Symbol => sym.isType
       case name: Name => name.isTypeName
     }
-    def apply(prefix: Type, designator: Designator)(implicit ctx: Context) =
+    def apply(prefix: Type, designator: Designator)(implicit ctx: Context): NamedType =
       if (isType(designator)) TypeRef.apply(prefix, designator)
       else TermRef.apply(prefix, designator)
-    def apply(prefix: Type, designator: Name, denot: Denotation)(implicit ctx: Context) =
+    def apply(prefix: Type, designator: Name, denot: Denotation)(implicit ctx: Context): NamedType =
       if (designator.isTermName) TermRef.apply(prefix, designator.asTermName, denot)
       else TypeRef.apply(prefix, designator.asTypeName, denot)
   }
@@ -2260,9 +2257,9 @@ object Types {
           // can happen in IDE if `cls` is stale
       }
 
-    override def computeHash(bs: Binders) = doHash(bs, tref)
+    override def computeHash(bs: Binders): Int = doHash(bs, tref)
 
-    override def eql(that: Type) = that match {
+    override def eql(that: Type): Boolean = that match {
       case that: ThisType => tref.eq(that.tref)
       case _ => false
     }
@@ -2272,7 +2269,7 @@ object Types {
 
   object ThisType {
     /** Normally one should use ClassSymbol#thisType instead */
-    def raw(tref: TypeRef)(implicit ctx: Context) =
+    def raw(tref: TypeRef)(implicit ctx: Context): CachedThisType =
       unique(new CachedThisType(tref))
   }
 
@@ -2281,16 +2278,16 @@ object Types {
    *  by `super`.
    */
   abstract case class SuperType(thistpe: Type, supertpe: Type) extends CachedProxyType with SingletonType {
-    override def underlying(implicit ctx: Context) = supertpe
-    override def superType(implicit ctx: Context) =
+    override def underlying(implicit ctx: Context): Type = supertpe
+    override def superType(implicit ctx: Context): Type =
       thistpe.baseType(supertpe.typeSymbol)
-    def derivedSuperType(thistpe: Type, supertpe: Type)(implicit ctx: Context) =
+    def derivedSuperType(thistpe: Type, supertpe: Type)(implicit ctx: Context): Type =
       if ((thistpe eq this.thistpe) && (supertpe eq this.supertpe)) this
       else SuperType(thistpe, supertpe)
 
-    override def computeHash(bs: Binders) = doHash(bs, thistpe, supertpe)
+    override def computeHash(bs: Binders): Int = doHash(bs, thistpe, supertpe)
 
-    override def eql(that: Type) = that match {
+    override def eql(that: Type): Boolean = that match {
       case that: SuperType => thistpe.eq(that.thistpe) && supertpe.eq(that.supertpe)
       case _ => false
     }
@@ -2307,15 +2304,15 @@ object Types {
 
   /** A constant type with  single `value`. */
   abstract case class ConstantType(value: Constant) extends CachedProxyType with SingletonType {
-    override def underlying(implicit ctx: Context) = value.tpe
+    override def underlying(implicit ctx: Context): Type = value.tpe
 
-    override def computeHash(bs: Binders) = doHash(value)
+    override def computeHash(bs: Binders): Int = doHash(value)
   }
 
   final class CachedConstantType(value: Constant) extends ConstantType(value)
 
   object ConstantType {
-    def apply(value: Constant)(implicit ctx: Context) = {
+    def apply(value: Constant)(implicit ctx: Context): ConstantType = {
       assertUnerased()
       unique(new CachedConstantType(value))
     }
@@ -2324,7 +2321,7 @@ object Types {
   case class LazyRef(private var refFn: Context => Type) extends UncachedProxyType with ValueType {
     private[this] var myRef: Type = null
     private[this] var computed = false
-    def ref(implicit ctx: Context) = {
+    def ref(implicit ctx: Context): Type = {
       if (computed) assert(myRef != null)
       else {
         computed = true
@@ -2333,12 +2330,12 @@ object Types {
       }
       myRef
     }
-    def evaluating = computed && myRef == null
-    def completed = myRef != null
-    override def underlying(implicit ctx: Context) = ref
-    override def toString = s"LazyRef(${if (computed) myRef else "..."})"
-    override def equals(other: Any) = this.eq(other.asInstanceOf[AnyRef])
-    override def hashCode = System.identityHashCode(this)
+    def evaluating: Boolean = computed && myRef == null
+    def completed: Boolean = myRef != null
+    override def underlying(implicit ctx: Context): Type = ref
+    override def toString: String = s"LazyRef(${if (computed) myRef else "..."})"
+    override def equals(other: Any): Boolean = this.eq(other.asInstanceOf[AnyRef])
+    override def hashCode: Int = System.identityHashCode(this)
   }
 
   // --- Refined Type and RecType ------------------------------------------------
@@ -2358,7 +2355,7 @@ object Types {
     else assert(refinedInfo.isInstanceOf[TypeType], this)
     assert(!refinedName.is(NameKinds.ExpandedName), this)
 
-    override def underlying(implicit ctx: Context) = parent
+    override def underlying(implicit ctx: Context): Type = parent
 
     private def badInst =
       throw new AssertionError(s"bad instantiation: $this")
@@ -2374,10 +2371,10 @@ object Types {
       if (parent.member(refinedName).exists) derivedRefinedType(parent, refinedName, refinedInfo)
       else parent
 
-    override def computeHash(bs: Binders) = doHash(bs, refinedName, refinedInfo, parent)
-    override def stableHash = refinedInfo.stableHash && parent.stableHash
+    override def computeHash(bs: Binders): Int = doHash(bs, refinedName, refinedInfo, parent)
+    override def stableHash: Boolean = refinedInfo.stableHash && parent.stableHash
 
-    override def eql(that: Type) = that match {
+    override def eql(that: Type): Boolean = that match {
       case that: RefinedType =>
         refinedName.eq(that.refinedName) &&
         refinedInfo.eq(that.refinedInfo) &&
@@ -2440,7 +2437,7 @@ object Types {
     private[Types] var opened: Boolean = false
     private[Types] var openedTwice: Boolean = false
 
-    val parent = parentExp(this)
+    val parent: Type = parentExp(this)
 
     private[this] var myRecThis: RecThis = null
 
@@ -2473,9 +2470,9 @@ object Types {
       refacc.apply(false, tp)
     }
 
-    override def computeHash(bs: Binders) = doHash(new Binders(this, bs), parent)
+    override def computeHash(bs: Binders): Int = doHash(new Binders(this, bs), parent)
 
-    override def stableHash = false
+    override def stableHash: Boolean = false
       // this is a conservative observation. By construction RecTypes contain at least
       // one RecThis occurrence. Since `stableHash` does not keep track of enclosing
       // bound types, it will return "unstable" for this occurrence and this would propagate.
@@ -2484,13 +2481,13 @@ object Types {
 
     override def equals(that: Any): Boolean = equals(that, null)
 
-    override def iso(that: Any, bs: BinderPairs) = that match {
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: RecType =>
         parent.equals(that.parent, new BinderPairs(this, that, bs))
       case _ => false
     }
 
-    override def toString = s"RecType($parent | $hashCode)"
+    override def toString: String = s"RecType($parent | $hashCode)"
 
     private def checkInst(implicit ctx: Context): this.type = this // debug hook
   }
@@ -2525,7 +2522,7 @@ object Types {
     }
 
     /** Create a `RecType`, but only if the type generated by `parentExp` is indeed recursive. */
-    def closeOver(parentExp: RecType => Type)(implicit ctx: Context) = {
+    def closeOver(parentExp: RecType => Type)(implicit ctx: Context): Type = {
       val rt = this(parentExp)
       if (rt.isReferredToBy(rt.parent)) rt else rt.parent
     }
@@ -2540,11 +2537,11 @@ object Types {
   }
 
   abstract case class AndType(tp1: Type, tp2: Type) extends AndOrType {
-    def isAnd = true
+    def isAnd: Boolean = true
     private[this] var myBaseClassesPeriod: Period = Nowhere
     private[this] var myBaseClasses: List[ClassSymbol] = _
     /** Base classes of are the merge of the operand base classes. */
-    override final def baseClasses(implicit ctx: Context) = {
+    override final def baseClasses(implicit ctx: Context): List[ClassSymbol] = {
       if (myBaseClassesPeriod != ctx.period) {
         val bcs1 = tp1.baseClasses
         val bcs1set = BaseClassSet(bcs1)
@@ -2570,9 +2567,9 @@ object Types {
       if ((tp1 eq this.tp1) && (tp2 eq this.tp2)) this
       else tp1 & tp2
 
-    override def computeHash(bs: Binders) = doHash(bs, tp1, tp2)
+    override def computeHash(bs: Binders): Int = doHash(bs, tp1, tp2)
 
-    override def eql(that: Type) = that match {
+    override def eql(that: Type): Boolean = that match {
       case that: AndType => tp1.eq(that.tp1) && tp2.eq(that.tp2)
       case _ => false
     }
@@ -2605,11 +2602,11 @@ object Types {
   }
 
   abstract case class OrType(tp1: Type, tp2: Type) extends AndOrType {
-    def isAnd = false
+    def isAnd: Boolean = false
     private[this] var myBaseClassesPeriod: Period = Nowhere
     private[this] var myBaseClasses: List[ClassSymbol] = _
     /** Base classes of are the intersection of the operand base classes. */
-    override final def baseClasses(implicit ctx: Context) = {
+    override final def baseClasses(implicit ctx: Context): List[ClassSymbol] = {
       if (myBaseClassesPeriod != ctx.period) {
         val bcs1 = tp1.baseClasses
         val bcs1set = BaseClassSet(bcs1)
@@ -2649,9 +2646,9 @@ object Types {
       if ((tp1 eq this.tp1) && (tp2 eq this.tp2)) this
       else OrType.make(tp1, tp2)
 
-    override def computeHash(bs: Binders) = doHash(bs, tp1, tp2)
+    override def computeHash(bs: Binders): Int = doHash(bs, tp1, tp2)
 
-    override def eql(that: Type) = that match {
+    override def eql(that: Type): Boolean = that match {
       case that: OrType => tp1.eq(that.tp1) && tp2.eq(that.tp2)
       case _ => false
     }
@@ -2660,7 +2657,7 @@ object Types {
   final class CachedOrType(tp1: Type, tp2: Type) extends OrType(tp1, tp2)
 
   object OrType {
-    def apply(tp1: Type, tp2: Type)(implicit ctx: Context) = {
+    def apply(tp1: Type, tp2: Type)(implicit ctx: Context): OrType = {
       assertUnerased()
       unique(new CachedOrType(tp1, tp2))
     }
@@ -2692,7 +2689,7 @@ object Types {
   }
 
   trait MethodicType extends SignatureCachingType {
-    protected def resultSignature(implicit ctx: Context) = try resultType match {
+    protected def resultSignature(implicit ctx: Context): Signature = try resultType match {
       case rtp: MethodicType => rtp.signature
       case tp =>
         if (tp.isRef(defn.UnitClass)) Signature(Nil, defn.UnitClass.fullName.asTypeName)
@@ -2713,18 +2710,18 @@ object Types {
 
     def computeSignature(implicit ctx: Context): Signature = resultSignature
 
-    def derivedExprType(resType: Type)(implicit ctx: Context) =
+    def derivedExprType(resType: Type)(implicit ctx: Context): ExprType =
       if (resType eq this.resType) this else ExprType(resType)
 
-    override def computeHash(bs: Binders) = doHash(bs, resType)
-    override def stableHash = resType.stableHash
+    override def computeHash(bs: Binders): Int = doHash(bs, resType)
+    override def stableHash: Boolean = resType.stableHash
 
-    override def eql(that: Type) = that match {
+    override def eql(that: Type): Boolean = that match {
       case that: ExprType => resType.eq(that.resType)
       case _ => false
     }
 
-    override def iso(that: Any, bs: BinderPairs) = that match {
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: ExprType => resType.equals(that.resType, bs)
       case _ => false
     }
@@ -2734,7 +2731,7 @@ object Types {
   final class CachedExprType(resultType: Type) extends ExprType(resultType)
 
   object ExprType {
-    def apply(resultType: Type)(implicit ctx: Context) = {
+    def apply(resultType: Type)(implicit ctx: Context): ExprType = {
       assertUnerased()
       unique(new CachedExprType(resultType))
     }
@@ -2758,14 +2755,14 @@ object Types {
     def resType: Type
     protected def newParamRef(n: Int): ParamRefType
 
-    override def resultType(implicit ctx: Context) = resType
+    override def resultType(implicit ctx: Context): Type = resType
 
     def isResultDependent(implicit ctx: Context): Boolean
     def isParamDependent(implicit ctx: Context): Boolean
 
-    final def isTermLambda = isInstanceOf[TermLambda]
-    final def isTypeLambda = isInstanceOf[TypeLambda]
-    final def isHigherKinded = isInstanceOf[TypeProxy]
+    final def isTermLambda: Boolean = isInstanceOf[TermLambda]
+    final def isTypeLambda: Boolean = isInstanceOf[TypeLambda]
+    final def isHigherKinded: Boolean = isInstanceOf[TypeProxy]
 
     private[this] var myParamRefs: List[ParamRefType] = null
 
@@ -2797,7 +2794,7 @@ object Types {
 
     final def derivedLambdaType(paramNames: List[ThisName] = this.paramNames,
                           paramInfos: List[PInfo] = this.paramInfos,
-                          resType: Type = this.resType)(implicit ctx: Context) =
+                          resType: Type = this.resType)(implicit ctx: Context): LambdaType =
       if ((paramNames eq this.paramNames) && (paramInfos eq this.paramInfos) && (resType eq this.resType)) this
       else newLikeThis(paramNames, paramInfos, resType)
 
@@ -2807,22 +2804,22 @@ object Types {
           x => resType.subst(this, x))
 
     protected def prefixString: String
-    final override def toString = s"$prefixString($paramNames, $paramInfos, $resType)"
+    final override def toString: String = s"$prefixString($paramNames, $paramInfos, $resType)"
   }
 
   abstract class HKLambda extends CachedProxyType with LambdaType {
-    final override def underlying(implicit ctx: Context) = resType
+    final override def underlying(implicit ctx: Context): Type = resType
 
-    override def computeHash(bs: Binders) =
+    override def computeHash(bs: Binders): Int =
       doHash(new Binders(this, bs), paramNames, resType, paramInfos)
 
-    override def stableHash = resType.stableHash && paramInfos.stableHash
+    override def stableHash: Boolean = resType.stableHash && paramInfos.stableHash
 
-    final override def equals(that: Any) = equals(that, null)
+    final override def equals(that: Any): Boolean = equals(that, null)
 
     // No definition of `eql` --> fall back on equals, which calls iso
 
-    final override def iso(that: Any, bs: BinderPairs) = that match {
+    final override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: HKLambda =>
         paramNames.eqElements(that.paramNames) &&
         companion.eq(that.companion) && {
@@ -2836,13 +2833,13 @@ object Types {
   }
 
   abstract class MethodOrPoly extends UncachedGroundType with LambdaType with MethodicType {
-    final override def hashCode = System.identityHashCode(this)
+    final override def hashCode: Int = System.identityHashCode(this)
 
-    final override def equals(that: Any) = equals(that, null)
+    final override def equals(that: Any): Boolean = equals(that, null)
 
     // No definition of `eql` --> fall back on equals, which is `eq`
 
-    final override def iso(that: Any, bs: BinderPairs) = that match {
+    final override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: MethodOrPoly =>
         paramNames.eqElements(that.paramNames) &&
         companion.eq(that.companion) && {
@@ -2971,12 +2968,11 @@ object Types {
       paramInfosExp: MethodType => List[Type],
       resultTypeExp: MethodType => Type)
     extends MethodOrPoly with TermLambda with NarrowCached { thisMethodType =>
-    import MethodType._
 
     type This = MethodType
 
-    val paramInfos = paramInfosExp(this)
-    val resType = resultTypeExp(this)
+    val paramInfos: List[Type] = paramInfosExp(this)
+    val resType: Type = resultTypeExp(this)
     assert(resType.exists)
 
     def companion: MethodTypeCompanion
@@ -2990,7 +2986,7 @@ object Types {
       resultSignature.prepend(params, isJavaMethod)
     }
 
-    protected def prefixString = "MethodType"
+    protected def prefixString: String = "MethodType"
   }
 
   final class CachedMethodType(paramNames: List[TermName])(paramInfosExp: MethodType => List[Type], resultTypeExp: MethodType => Type, val companion: MethodTypeCompanion)
@@ -3027,7 +3023,7 @@ object Types {
   abstract class TermLambdaCompanion[LT <: TermLambda]
   extends LambdaTypeCompanion[TermName, Type, LT] {
     def toPInfo(tp: Type)(implicit ctx: Context): Type = tp
-    def syntheticParamName(n: Int) = nme.syntheticParamName(n)
+    def syntheticParamName(n: Int): TermName = nme.syntheticParamName(n)
   }
 
   abstract class TypeLambdaCompanion[LT <: TypeLambda]
@@ -3036,7 +3032,7 @@ object Types {
       case tp: TypeBounds => tp
       case tp: ErrorType => TypeAlias(tp)
     }
-    def syntheticParamName(n: Int) = tpnme.syntheticTypeParamName(n)
+    def syntheticParamName(n: Int): TypeName = tpnme.syntheticTypeParamName(n)
   }
 
   abstract class MethodTypeCompanion extends TermLambdaCompanion[MethodType] { self =>
@@ -3046,7 +3042,7 @@ object Types {
      *   - replace @repeated annotations on Seq or Array types by <repeated> types
      *   - add @inlineParam to inline call-by-value parameters
      */
-    def fromSymbols(params: List[Symbol], resultType: Type)(implicit ctx: Context) = {
+    def fromSymbols(params: List[Symbol], resultType: Type)(implicit ctx: Context): MethodType = {
       def translateInline(tp: Type): Type = tp match {
         case _: ExprType => tp
         case _ => AnnotatedType(tp, Annotation(defn.InlineParamAnnot))
@@ -3095,7 +3091,7 @@ object Types {
 
   /** A ternary extractor for MethodType */
   object MethodTpe {
-    def unapply(mt: MethodType)(implicit ctx: Context) =
+    def unapply(mt: MethodType)(implicit ctx: Context): Some[(List[TermName], List[Type], Type)] =
       Some((mt.paramNames, mt.paramInfos, mt.resultType))
   }
 
@@ -3141,7 +3137,7 @@ object Types {
       paramInfosExp: HKTypeLambda => List[TypeBounds], resultTypeExp: HKTypeLambda => Type)
   extends HKLambda with TypeLambda {
     type This = HKTypeLambda
-    def companion = HKTypeLambda
+    def companion: HKTypeLambda.type = HKTypeLambda
 
     val paramInfos: List[TypeBounds] = paramInfosExp(this)
     val resType: Type = resultTypeExp(this)
@@ -3149,7 +3145,7 @@ object Types {
     assert(resType.isInstanceOf[TermType], this)
     assert(paramNames.nonEmpty)
 
-    protected def prefixString = "HKTypeLambda"
+    protected def prefixString: String = "HKTypeLambda"
   }
 
   /** The type of a polymorphic method. It has the same form as HKTypeLambda,
@@ -3160,7 +3156,7 @@ object Types {
   extends MethodOrPoly with TypeLambda {
 
     type This = PolyType
-    def companion = PolyType
+    def companion: PolyType.type = PolyType
 
     val paramInfos: List[TypeBounds] = paramInfosExp(this)
     val resType: Type = resultTypeExp(this)
@@ -3168,7 +3164,7 @@ object Types {
     assert(resType.isInstanceOf[TermType], this)
     assert(paramNames.nonEmpty)
 
-    def computeSignature(implicit ctx: Context) = resultSignature
+    def computeSignature(implicit ctx: Context): Signature = resultSignature
 
     /** Merge nested polytypes into one polytype. nested polytypes are normally not supported
      *  but can arise as temporary data structures.
@@ -3188,7 +3184,7 @@ object Types {
       case _ => this
     }
 
-    protected def prefixString = "PolyType"
+    protected def prefixString: String = "PolyType"
   }
 
   object HKTypeLambda extends TypeLambdaCompanion[HKTypeLambda] {
@@ -3201,7 +3197,7 @@ object Types {
     def unapply(tl: HKTypeLambda): Some[(List[LambdaParam], Type)] =
       Some((tl.typeParams, tl.resType))
 
-    def any(n: Int)(implicit ctx: Context) =
+    def any(n: Int)(implicit ctx: Context): HKTypeLambda =
       apply(syntheticParamNames(n))(
         pt => List.fill(n)(TypeBounds.empty), pt => defn.AnyType)
 
@@ -3238,7 +3234,7 @@ object Types {
     def unapply(tl: PolyType): Some[(List[LambdaParam], Type)] =
       Some((tl.typeParams, tl.resType))
 
-    def any(n: Int)(implicit ctx: Context) =
+    def any(n: Int)(implicit ctx: Context): PolyType =
       apply(syntheticParamNames(n))(
         pt => List.fill(n)(TypeBounds.empty), pt => defn.AnyType)
   }
@@ -3258,10 +3254,10 @@ object Types {
   /** The parameter of a type lambda */
   case class LambdaParam(tl: TypeLambda, n: Int) extends ParamInfo {
     type ThisName = TypeName
-    def isTypeParam(implicit ctx: Context) = tl.paramNames.head.isTypeName
-    def paramName(implicit ctx: Context) = tl.paramNames(n)
-    def paramInfo(implicit ctx: Context) = tl.paramInfos(n)
-    def paramInfoAsSeenFrom(pre: Type)(implicit ctx: Context) = paramInfo
+    def isTypeParam(implicit ctx: Context): Boolean = tl.paramNames.head.isTypeName
+    def paramName(implicit ctx: Context): tl.ThisName = tl.paramNames(n)
+    def paramInfo(implicit ctx: Context): tl.PInfo = tl.paramInfos(n)
+    def paramInfoAsSeenFrom(pre: Type)(implicit ctx: Context): tl.PInfo = paramInfo
     def paramInfoOrCompleter(implicit ctx: Context): Type = paramInfo
     def paramVariance(implicit ctx: Context): Int = tl.paramNames(n).variance
     def paramRef(implicit ctx: Context): Type = tl.paramRefs(n)
@@ -3324,7 +3320,7 @@ object Types {
         NoType
     }
 
-    def lowerBound(implicit ctx: Context) = tycon.stripTypeVar match {
+    def lowerBound(implicit ctx: Context): Type = tycon.stripTypeVar match {
       case tycon: TypeRef =>
         tycon.info match {
           case TypeBounds(lo, hi) =>
@@ -3345,16 +3341,16 @@ object Types {
       if ((tycon eq this.tycon) && (args eq this.args)) this
       else tycon.appliedTo(args)
 
-    override def computeHash(bs: Binders) = doHash(bs, tycon, args)
+    override def computeHash(bs: Binders): Int = doHash(bs, tycon, args)
 
-    override def stableHash = {
+    override def stableHash: Boolean = {
       if (myStableHash == 0) myStableHash = if (tycon.stableHash && args.stableHash) 1 else -1
       myStableHash > 0
     }
 
-    override def eql(that: Type) = this `eq` that // safe because applied types are hash-consed separately
+    override def eql(that: Type): Boolean = this `eq` that // safe because applied types are hash-consed separately
 
-    final override def iso(that: Any, bs: BinderPairs) = that match {
+    final override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: AppliedType => tycon.equals(that.tycon, bs) && args.equalElements(that.args, bs)
       case _ => false
     }
@@ -3366,7 +3362,7 @@ object Types {
   }
 
   object AppliedType {
-    def apply(tycon: Type, args: List[Type])(implicit ctx: Context) = {
+    def apply(tycon: Type, args: List[Type])(implicit ctx: Context): AppliedType = {
       assertUnerased()
       ctx.base.uniqueAppliedTypes.enterIfNew(tycon, args)
     }
@@ -3378,7 +3374,7 @@ object Types {
     type BT <: Type
     val binder: BT
     def copyBoundType(bt: BT): Type
-    override def stableHash = false
+    override def stableHash: Boolean = false
   }
 
   abstract class ParamRef extends BoundType {
@@ -3392,18 +3388,18 @@ object Types {
       else infos(paramNum)
     }
 
-    override def computeHash(bs: Binders) = doHash(paramNum, binder.identityHash(bs))
+    override def computeHash(bs: Binders): Int = doHash(paramNum, binder.identityHash(bs))
 
-    override def equals(that: Any) = equals(that, null)
+    override def equals(that: Any): Boolean = equals(that, null)
 
-    override def iso(that: Any, bs: BinderPairs) = that match {
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: ParamRef => paramNum == that.paramNum && binder.equalBinder(that.binder, bs)
       case _ => false
     }
 
     protected def kindString: String
 
-    override def toString =
+    override def toString: String =
       try s"${kindString}ParamRef($paramName)"
       catch {
         case ex: IndexOutOfBoundsException => s"ParamRef(<bad index: $paramNum>)"
@@ -3415,8 +3411,8 @@ object Types {
    */
   abstract case class TermParamRef(binder: TermLambda, paramNum: Int) extends ParamRef with SingletonType {
     type BT = TermLambda
-    def kindString = "Term"
-    def copyBoundType(bt: BT) = bt.paramRefs(paramNum)
+    def kindString: String = "Term"
+    def copyBoundType(bt: BT): Type = bt.paramRefs(paramNum)
   }
 
   private final class TermParamRefImpl(binder: TermLambda, paramNum: Int) extends TermParamRef(binder, paramNum)
@@ -3426,13 +3422,13 @@ object Types {
    */
   abstract case class TypeParamRef(binder: TypeLambda, paramNum: Int) extends ParamRef {
     type BT = TypeLambda
-    def kindString = "Type"
-    def copyBoundType(bt: BT) = bt.paramRefs(paramNum)
+    def kindString: String = "Type"
+    def copyBoundType(bt: BT): Type = bt.paramRefs(paramNum)
 
     /** Optimized version of occursIn, avoid quadratic blowup when solving
      *  constraints over large ground types.
      */
-    override def occursIn(that: Type)(implicit ctx: Context) = !that.isGround && super.occursIn(that)
+    override def occursIn(that: Type)(implicit ctx: Context): Boolean = !that.isGround && super.occursIn(that)
 
     /** Looking only at the structure of `bound`, is one of the following true?
      *     - fromBelow and param <:< bound
@@ -3453,21 +3449,21 @@ object Types {
    */
   abstract case class RecThis(binder: RecType) extends BoundType with SingletonType {
     type BT = RecType
-    override def underlying(implicit ctx: Context) = binder
-    def copyBoundType(bt: BT) = bt.recThis
+    override def underlying(implicit ctx: Context): RecType = binder
+    def copyBoundType(bt: BT): RecThis = bt.recThis
 
     // need to customize hashCode and equals to prevent infinite recursion
     // between RecTypes and RecRefs.
-    override def computeHash(bs: Binders) = addDelta(binder.identityHash(bs), 41)
+    override def computeHash(bs: Binders): Int = addDelta(binder.identityHash(bs), 41)
 
-    override def equals(that: Any) = equals(that, null)
+    override def equals(that: Any): Boolean = equals(that, null)
 
-    override def iso(that: Any, bs: BinderPairs) = that match {
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: RecThis => binder.equalBinder(that.binder, bs)
       case _ => false
     }
 
-    override def toString =
+    override def toString: String =
       try s"RecThis(${binder.hashCode})"
       catch {
         case ex: NullPointerException => s"RecThis(<under construction>)"
@@ -3480,11 +3476,11 @@ object Types {
 
   /** A skolem type reference with underlying type `binder`. */
   case class SkolemType(info: Type) extends UncachedProxyType with ValueType with SingletonType {
-    override def underlying(implicit ctx: Context) = info
-    def derivedSkolemType(info: Type)(implicit ctx: Context) =
+    override def underlying(implicit ctx: Context): Type = info
+    def derivedSkolemType(info: Type)(implicit ctx: Context): SkolemType =
       if (info eq this.info) this else SkolemType(info)
     override def hashCode: Int = System.identityHashCode(this)
-    override def equals(that: Any) = this.eq(that.asInstanceOf[AnyRef])
+    override def equals(that: Any): Boolean = this.eq(that.asInstanceOf[AnyRef])
 
     def withName(name: Name): this.type = { myRepr = name; this }
 
@@ -3494,7 +3490,7 @@ object Types {
       myRepr
     }
 
-    override def toString = s"Skolem($hashCode)"
+    override def toString: String = s"Skolem($hashCode)"
   }
 
   // ------------ Type variables ----------------------------------------
@@ -3521,8 +3517,8 @@ object Types {
     /** The permanent instance type of the variable, or NoType is none is given yet */
     private[this] var myInst: Type = NoType
 
-    private[core] def inst = myInst
-    private[core] def inst_=(tp: Type) = {
+    private[core] def inst: Type = myInst
+    private[core] def inst_=(tp: Type): Unit = {
       myInst = tp
       if (tp.exists) {
         owningState.get.ownedVars -= this
@@ -3533,7 +3529,7 @@ object Types {
     /** The state owning the variable. This is at first `creatorState`, but it can
      *  be changed to an enclosing state on a commit.
      */
-    private[core] var owningState = new WeakReference(creatorState)
+    private[core] var owningState: WeakReference[TyperState] = new WeakReference(creatorState)
 
     /** The instance type of this variable, or NoType if the variable is currently
      *  uninstantiated
@@ -3542,7 +3538,7 @@ object Types {
       if (inst.exists) inst else ctx.typerState.instType(this)
 
     /** Is the variable already instantiated? */
-    def isInstantiated(implicit ctx: Context) = instanceOpt.exists
+    def isInstantiated(implicit ctx: Context): Boolean = instanceOpt.exists
 
     /** Instantiate variable with given type */
     def instantiateWith(tp: Type)(implicit ctx: Context): Type = {
@@ -3565,7 +3561,7 @@ object Types {
       instantiateWith(ctx.typeComparer.instanceType(origin, fromBelow))
 
     /** For uninstantiated type variables: Is the lower bound different from Nothing? */
-    def hasLowerBound(implicit ctx: Context) =
+    def hasLowerBound(implicit ctx: Context): Boolean =
       !ctx.typerState.constraint.entry(origin).loBound.isBottomType
 
     /** Unwrap to instance (if instantiated) or origin (if not), until result
@@ -3583,9 +3579,9 @@ object Types {
     }
 
     override def computeHash(bs: Binders): Int = identityHash(bs)
-    override def equals(that: Any) = this.eq(that.asInstanceOf[AnyRef])
+    override def equals(that: Any): Boolean = this.eq(that.asInstanceOf[AnyRef])
 
-    override def toString = {
+    override def toString: String = {
       def instStr = if (inst.exists) s" -> $inst" else ""
       s"TypeVar($origin$instStr)"
     }
@@ -3605,7 +3601,7 @@ object Types {
    */
   abstract case class MatchType(bound: Type, scrutinee: Type, cases: List[Type]) extends CachedProxyType with ValueType {
 
-    def derivedMatchType(bound: Type, scrutinee: Type, cases: List[Type])(implicit ctx: Context) =
+    def derivedMatchType(bound: Type, scrutinee: Type, cases: List[Type])(implicit ctx: Context): MatchType =
       if (bound.eq(this.bound) && scrutinee.eq(this.scrutinee) && cases.eqElements(this.cases)) this
       else MatchType(bound, scrutinee, cases)
 
@@ -3625,7 +3621,7 @@ object Types {
     /** Switch to choose parallel or sequential reduction */
     private final val reduceInParallel = false
 
-    final def cantPossiblyMatch(cas: Type)(implicit ctx: Context) =
+    final def cantPossiblyMatch(cas: Type)(implicit ctx: Context): Boolean =
       true  // should be refined if we allow overlapping cases
 
     def reduced(implicit ctx: Context): Type = {
@@ -3703,9 +3699,9 @@ object Types {
       myReduced
     }
 
-    override def computeHash(bs: Binders) = doHash(bs, scrutinee, bound :: cases)
+    override def computeHash(bs: Binders): Int = doHash(bs, scrutinee, bound :: cases)
 
-    override def eql(that: Type) = that match {
+    override def eql(that: Type): Boolean = that match {
       case that: MatchType =>
         bound.eq(that.bound) && scrutinee.eq(that.scrutinee) && cases.eqElements(that.cases)
       case _ => false
@@ -3715,7 +3711,7 @@ object Types {
   class CachedMatchType(bound: Type, scrutinee: Type, cases: List[Type]) extends MatchType(bound, scrutinee, cases)
 
   object MatchType {
-    def apply(bound: Type, scrutinee: Type, cases: List[Type])(implicit ctx: Context) =
+    def apply(bound: Type, scrutinee: Type, cases: List[Type])(implicit ctx: Context): MatchType =
       unique(new CachedMatchType(bound, scrutinee, cases))
   }
 
@@ -3776,18 +3772,18 @@ object Types {
       parentsCache
     }
 
-    def derivedClassInfo(prefix: Type)(implicit ctx: Context) =
+    def derivedClassInfo(prefix: Type)(implicit ctx: Context): ClassInfo =
       if (prefix eq this.prefix) this
       else ClassInfo(prefix, cls, classParents, decls, selfInfo)
 
-    def derivedClassInfo(prefix: Type = this.prefix, classParents: List[Type] = this.classParents, decls: Scope = this.decls, selfInfo: TypeOrSymbol = this.selfInfo)(implicit ctx: Context) =
+    def derivedClassInfo(prefix: Type = this.prefix, classParents: List[Type] = this.classParents, decls: Scope = this.decls, selfInfo: TypeOrSymbol = this.selfInfo)(implicit ctx: Context): ClassInfo =
       if ((prefix eq this.prefix) && (classParents eq this.classParents) && (decls eq this.decls) && (selfInfo eq this.selfInfo)) this
       else ClassInfo(prefix, cls, classParents, decls, selfInfo)
 
-    override def computeHash(bs: Binders) = doHash(bs, cls, prefix)
-    override def stableHash = prefix.stableHash && classParents.stableHash
+    override def computeHash(bs: Binders): Int = doHash(bs, cls, prefix)
+    override def stableHash: Boolean = prefix.stableHash && classParents.stableHash
 
-    override def eql(that: Type) = that match {
+    override def eql(that: Type): Boolean = that match {
       case that: ClassInfo =>
         prefix.eq(that.prefix) &&
         cls.eq(that.cls) &&
@@ -3799,7 +3795,7 @@ object Types {
 
     override def equals(that: Any): Boolean = equals(that, null)
 
-    override def iso(that: Any, bs: BinderPairs) = that match {
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: ClassInfo =>
         prefix.equals(that.prefix, bs) &&
         cls.eq(that.cls) &&
@@ -3809,7 +3805,7 @@ object Types {
       case _ => false
     }
 
-    override def toString = s"ClassInfo($prefix, $cls, $classParents)"
+    override def toString: String = s"ClassInfo($prefix, $cls, $classParents)"
   }
 
   class CachedClassInfo(prefix: Type, cls: ClassSymbol, classParents: List[Type], decls: Scope, selfInfo: TypeOrSymbol)
@@ -3820,18 +3816,18 @@ object Types {
   extends CachedClassInfo(prefix, cls, Nil, decls, selfInfo) {
 
     /** Install classinfo with known parents in `denot` s */
-    def finalize(denot: SymDenotation, parents: List[Type])(implicit ctx: Context) =
+    def finalize(denot: SymDenotation, parents: List[Type])(implicit ctx: Context): Unit =
       denot.info = ClassInfo(prefix, cls, parents, decls, selfInfo)
 
-    override def derivedClassInfo(prefix: Type)(implicit ctx: Context) =
+    override def derivedClassInfo(prefix: Type)(implicit ctx: Context): ClassInfo =
       if (prefix eq this.prefix) this
       else new TempClassInfo(prefix, cls, decls, selfInfo)
 
-    override def toString = s"TempClassInfo($prefix, $cls)"
+    override def toString: String = s"TempClassInfo($prefix, $cls)"
   }
 
   object ClassInfo {
-    def apply(prefix: Type, cls: ClassSymbol, classParents: List[Type], decls: Scope, selfInfo: TypeOrSymbol = NoType)(implicit ctx: Context) =
+    def apply(prefix: Type, cls: ClassSymbol, classParents: List[Type], decls: Scope, selfInfo: TypeOrSymbol = NoType)(implicit ctx: Context): ClassInfo =
       unique(new CachedClassInfo(prefix, cls, classParents, decls, selfInfo))
   }
 
@@ -3844,7 +3840,7 @@ object Types {
     override def underlying(implicit ctx: Context): Type = hi
 
     /** The non-alias type bounds type with given bounds */
-    def derivedTypeBounds(lo: Type, hi: Type)(implicit ctx: Context) =
+    def derivedTypeBounds(lo: Type, hi: Type)(implicit ctx: Context): TypeBounds =
       if ((lo eq this.lo) && (hi eq this.hi)) this
       else TypeBounds(lo, hi)
 
@@ -3870,18 +3866,18 @@ object Types {
       else if ((that.lo frozen_<:< this.lo) && (this.hi frozen_<:< that.hi)) that
       else TypeBounds(this.lo & that.lo, this.hi | that.hi)
 
-    override def & (that: Type)(implicit ctx: Context) = that match {
+    override def & (that: Type)(implicit ctx: Context): Type = that match {
       case that: TypeBounds => this & that
       case _ => super.& (that)
     }
 
-    override def | (that: Type)(implicit ctx: Context) = that match {
+    override def | (that: Type)(implicit ctx: Context): Type = that match {
       case that: TypeBounds => this | that
       case _ => super.| (that)
     }
 
-    override def computeHash(bs: Binders) = doHash(bs, lo, hi)
-    override def stableHash = lo.stableHash && hi.stableHash
+    override def computeHash(bs: Binders): Int = doHash(bs, lo, hi)
+    override def stableHash: Boolean = lo.stableHash && hi.stableHash
 
     override def equals(that: Any): Boolean = equals(that, null)
 
@@ -3891,7 +3887,7 @@ object Types {
       case _ => false
     }
 
-    override def eql(that: Type) = that match {
+    override def eql(that: Type): Boolean = that match {
       case that: AliasingBounds => false
       case that: TypeBounds => lo.eq(that.lo) && hi.eq(that.hi)
       case _ => false
@@ -3905,8 +3901,8 @@ object Types {
 
     def derivedAlias(alias: Type)(implicit ctx: Context): AliasingBounds
 
-    override def computeHash(bs: Binders) = doHash(bs, alias)
-    override def stableHash = alias.stableHash
+    override def computeHash(bs: Binders): Int = doHash(bs, alias)
+    override def stableHash: Boolean = alias.stableHash
 
     override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: AliasingBounds => this.isTypeAlias == that.isTypeAlias && alias.equals(that.alias, bs)
@@ -3923,7 +3919,7 @@ object Types {
   /**    = T
    */
   class TypeAlias(alias: Type) extends AliasingBounds(alias) {
-    def derivedAlias(alias: Type)(implicit ctx: Context) =
+    def derivedAlias(alias: Type)(implicit ctx: Context): AliasingBounds =
       if (alias eq this.alias) this else TypeAlias(alias)
   }
 
@@ -3935,25 +3931,25 @@ object Types {
    *  aliases (or else take the jump and allow full recursive types).
    */
   class MatchAlias(alias: Type) extends AliasingBounds(alias) {
-    def derivedAlias(alias: Type)(implicit ctx: Context) =
+    def derivedAlias(alias: Type)(implicit ctx: Context): AliasingBounds =
       if (alias eq this.alias) this else MatchAlias(alias)
   }
 
   object TypeBounds {
     def apply(lo: Type, hi: Type)(implicit ctx: Context): TypeBounds =
       unique(new RealTypeBounds(lo, hi))
-    def empty(implicit ctx: Context) = apply(defn.NothingType, defn.AnyType)
-    def upper(hi: Type)(implicit ctx: Context) = apply(defn.NothingType, hi)
-    def lower(lo: Type)(implicit ctx: Context) = apply(lo, defn.AnyType)
+    def empty(implicit ctx: Context): TypeBounds = apply(defn.NothingType, defn.AnyType)
+    def upper(hi: Type)(implicit ctx: Context): TypeBounds = apply(defn.NothingType, hi)
+    def lower(lo: Type)(implicit ctx: Context): TypeBounds = apply(lo, defn.AnyType)
   }
 
   object TypeAlias {
-    def apply(alias: Type)(implicit ctx: Context) = unique(new TypeAlias(alias))
+    def apply(alias: Type)(implicit ctx: Context): TypeAlias = unique(new TypeAlias(alias))
     def unapply(tp: TypeAlias): Option[Type] = Some(tp.alias)
   }
 
   object MatchAlias {
-    def apply(alias: Type)(implicit ctx: Context) = unique(new MatchAlias(alias))
+    def apply(alias: Type)(implicit ctx: Context): MatchAlias = unique(new MatchAlias(alias))
     def unapply(tp: MatchAlias): Option[Type] = Some(tp.alias)
   }
 
@@ -3965,7 +3961,7 @@ object Types {
 
     override def underlying(implicit ctx: Context): Type = parent
 
-    def derivedAnnotatedType(parent: Type, annot: Annotation) =
+    def derivedAnnotatedType(parent: Type, annot: Annotation): AnnotatedType =
       if ((parent eq this.parent) && (annot eq this.annot)) this
       else AnnotatedType(parent, annot)
 
@@ -3977,7 +3973,7 @@ object Types {
     private[this] var isRefiningKnown = false
     private[this] var isRefiningCache: Boolean = _
 
-    def isRefining(implicit ctx: Context) = {
+    def isRefining(implicit ctx: Context): Boolean = {
       if (!isRefiningKnown) {
         isRefiningCache = annot.symbol.derivesFrom(defn.RefiningAnnotationClass)
         isRefiningKnown = true
@@ -3993,7 +3989,7 @@ object Types {
   }
 
   object AnnotatedType {
-    def make(underlying: Type, annots: List[Annotation]) =
+    def make(underlying: Type, annots: List[Annotation]): Type =
       (underlying /: annots)(AnnotatedType(_, _))
   }
 
@@ -4001,20 +3997,20 @@ object Types {
 
   /** The type of an erased array */
   abstract case class JavaArrayType(elemType: Type) extends CachedGroundType with ValueType {
-    def derivedJavaArrayType(elemtp: Type)(implicit ctx: Context) =
+    def derivedJavaArrayType(elemtp: Type)(implicit ctx: Context): JavaArrayType =
       if (elemtp eq this.elemType) this else JavaArrayType(elemtp)
 
-    override def computeHash(bs: Binders) = doHash(bs, elemType)
-    override def stableHash = elemType.stableHash
+    override def computeHash(bs: Binders): Int = doHash(bs, elemType)
+    override def stableHash: Boolean = elemType.stableHash
 
-    override def eql(that: Type) = that match {
+    override def eql(that: Type): Boolean = that match {
       case that: JavaArrayType => elemType.eq(that.elemType)
       case _ => false
     }
   }
   final class CachedJavaArrayType(elemType: Type) extends JavaArrayType(elemType)
   object JavaArrayType {
-    def apply(elemType: Type)(implicit ctx: Context) = unique(new CachedJavaArrayType(elemType))
+    def apply(elemType: Type)(implicit ctx: Context): JavaArrayType = unique(new CachedJavaArrayType(elemType))
   }
 
   /** The type of an import clause tree */
@@ -4022,12 +4018,12 @@ object Types {
 
   /** Sentinel for "missing type" */
   @sharable case object NoType extends CachedGroundType {
-    override def computeHash(bs: Binders) = hashSeed
+    override def computeHash(bs: Binders): Int = hashSeed
   }
 
   /** Missing prefix */
   @sharable case object NoPrefix extends CachedGroundType {
-    override def computeHash(bs: Binders) = hashSeed
+    override def computeHash(bs: Binders): Int = hashSeed
   }
 
   /** A common superclass of `ErrorType` and `TryDynamicCallSite`. Instances of this
@@ -4062,20 +4058,20 @@ object Types {
 
   /** Wildcard type, possibly with bounds */
   abstract case class WildcardType(optBounds: Type) extends CachedGroundType with TermType {
-    def derivedWildcardType(optBounds: Type)(implicit ctx: Context) =
+    def derivedWildcardType(optBounds: Type)(implicit ctx: Context): WildcardType =
       if (optBounds eq this.optBounds) this
       else if (!optBounds.exists) WildcardType
       else WildcardType(optBounds.asInstanceOf[TypeBounds])
 
-    override def computeHash(bs: Binders) = doHash(bs, optBounds)
-    override def stableHash = optBounds.stableHash
+    override def computeHash(bs: Binders): Int = doHash(bs, optBounds)
+    override def stableHash: Boolean = optBounds.stableHash
 
-    override def eql(that: Type) = that match {
+    override def eql(that: Type): Boolean = that match {
       case that: WildcardType => optBounds.eq(that.optBounds)
       case _ => false
     }
 
-    override def iso(that: Any, bs: BinderPairs) = that match {
+    override def iso(that: Any, bs: BinderPairs): Boolean = that match {
       case that: WildcardType => optBounds.equals(that.optBounds, bs)
       case _ => false
     }
@@ -4085,7 +4081,7 @@ object Types {
   final class CachedWildcardType(optBounds: Type) extends WildcardType(optBounds)
 
   @sharable object WildcardType extends WildcardType(NoType) {
-    def apply(bounds: TypeBounds)(implicit ctx: Context) = unique(new CachedWildcardType(bounds))
+    def apply(bounds: TypeBounds)(implicit ctx: Context): WildcardType = unique(new CachedWildcardType(bounds))
   }
 
   /** An extractor for single abstract method types.
@@ -4191,7 +4187,7 @@ object Types {
 
   /** Common base class of TypeMap and TypeAccumulator */
   abstract class VariantTraversal {
-    protected[core] var variance = 1
+    protected[core] var variance: Int = 1
 
     @forceInline protected def atVariance[T](v: Int)(op: => T): T = {
       val saved = variance
@@ -4205,7 +4201,7 @@ object Types {
   abstract class TypeMap(implicit protected val ctx: Context)
   extends VariantTraversal with (Type => Type) { thisMap =>
 
-    protected def stopAtStatic = true
+    protected def stopAtStatic: Boolean = true
 
     def apply(tp: Type): Type
 
@@ -4372,7 +4368,7 @@ object Types {
       derivedClassInfo(tp, this(tp.prefix))
 
     /** A version of mapClassInfo which also maps parents and self type */
-    protected def mapFullClassInfo(tp: ClassInfo) =
+    protected def mapFullClassInfo(tp: ClassInfo): ClassInfo =
       tp.derivedClassInfo(
         prefix = this(tp.prefix),
         classParents = tp.classParents.mapConserve(this),
@@ -4390,7 +4386,7 @@ object Types {
 
   /** A type map that maps also parents and self type of a ClassInfo */
   abstract class DeepTypeMap(implicit ctx: Context) extends TypeMap {
-    override def mapClassInfo(tp: ClassInfo) = {
+    override def mapClassInfo(tp: ClassInfo): ClassInfo = {
       val prefix1 = this(tp.prefix)
       val parents1 = tp.parents mapConserve this
       val selfInfo1 = tp.selfInfo match {
@@ -4402,8 +4398,8 @@ object Types {
   }
 
   @sharable object IdentityTypeMap extends TypeMap()(NoContext) {
-    override def stopAtStatic = true
-    def apply(tp: Type) = tp
+    override def stopAtStatic: Boolean = true
+    def apply(tp: Type): Type = tp
   }
 
   /** A type map that approximates TypeBounds types depending on
@@ -4415,24 +4411,24 @@ object Types {
    */
   abstract class ApproximatingTypeMap(implicit ctx: Context) extends TypeMap { thisMap =>
 
-    protected def range(lo: Type, hi: Type) =
+    protected def range(lo: Type, hi: Type): Type =
       if (variance > 0) hi
       else if (variance < 0) lo
       else Range(lower(lo), upper(hi))
 
-    protected def isRange(tp: Type) = tp.isInstanceOf[Range]
+    protected def isRange(tp: Type): Boolean = tp.isInstanceOf[Range]
 
-    protected def lower(tp: Type) = tp match {
+    protected def lower(tp: Type): Type = tp match {
       case tp: Range => tp.lo
       case _ => tp
     }
 
-    protected def upper(tp: Type) = tp match {
+    protected def upper(tp: Type): Type = tp match {
       case tp: Range => tp.hi
       case _ => tp
     }
 
-    protected def rangeToBounds(tp: Type) = tp match {
+    protected def rangeToBounds(tp: Type): Type = tp match {
       case Range(lo, hi) => TypeBounds(lo, hi)
       case _ => tp
     }
@@ -4466,7 +4462,7 @@ object Types {
      *  If the expansion is a wildcard parameter reference, convert its
      *  underlying bounds to a range, otherwise return the expansion.
      */
-    def expandParam(tp: NamedType, pre: Type) = tp.argForParam(pre) match {
+    def expandParam(tp: NamedType, pre: Type): Type = tp.argForParam(pre) match {
       case arg @ TypeRef(pre, _) if pre.isArgPrefixOf(arg.symbol) =>
         arg.info match {
           case TypeBounds(lo, hi) => range(atVariance(-variance)(reapply(lo)), reapply(hi))
@@ -4478,7 +4474,7 @@ object Types {
     /** Derived selection.
      *  @pre   the (upper bound of) prefix `pre` has a member named `tp.name`.
      */
-    override protected def derivedSelect(tp: NamedType, pre: Type) =
+    override protected def derivedSelect(tp: NamedType, pre: Type): Type =
       if (pre eq tp.prefix) tp
       else pre match {
         case Range(preLo, preHi) =>
@@ -4491,7 +4487,7 @@ object Types {
           super.derivedSelect(tp, pre)
       }
 
-    override protected def derivedRefinedType(tp: RefinedType, parent: Type, info: Type) =
+    override protected def derivedRefinedType(tp: RefinedType, parent: Type, info: Type): Type =
       if ((parent eq tp.parent) && (info eq tp.refinedInfo)) tp
       else parent match {
         case Range(parentLo, parentHi) =>
@@ -4512,14 +4508,14 @@ object Types {
           }
         }
 
-    override protected def derivedRecType(tp: RecType, parent: Type) =
+    override protected def derivedRecType(tp: RecType, parent: Type): Type =
       if (parent eq tp.parent) tp
       else parent match {
         case Range(lo, hi) => range(tp.rebind(lo), tp.rebind(hi))
         case _ => tp.rebind(parent)
       }
 
-    override protected def derivedAlias(tp: AliasingBounds, alias: Type) =
+    override protected def derivedAlias(tp: AliasingBounds, alias: Type): Type =
       if (alias eq tp.alias) tp
       else alias match {
         case Range(lo, hi) =>
@@ -4528,14 +4524,14 @@ object Types {
         case _ => tp.derivedAlias(alias)
       }
 
-    override protected def derivedTypeBounds(tp: TypeBounds, lo: Type, hi: Type) =
+    override protected def derivedTypeBounds(tp: TypeBounds, lo: Type, hi: Type): Type =
       if ((lo eq tp.lo) && (hi eq tp.hi)) tp
       else if (isRange(lo) || isRange(hi))
         if (variance > 0) TypeBounds(lower(lo), upper(hi))
         else range(TypeBounds(upper(lo), lower(hi)), TypeBounds(lower(lo), upper(hi)))
       else tp.derivedTypeBounds(lo, hi)
 
-    override protected def derivedSuperType(tp: SuperType, thistp: Type, supertp: Type) =
+    override protected def derivedSuperType(tp: SuperType, thistp: Type, supertp: Type): Type =
       if (isRange(thistp) || isRange(supertp)) range(defn.NothingType, defn.AnyType)
       else tp.derivedSuperType(thistp, supertp)
 
@@ -4580,15 +4576,15 @@ object Types {
           else tp.derivedAppliedType(tycon, args)
       }
 
-    override protected def derivedAndType(tp: AndType, tp1: Type, tp2: Type) =
+    override protected def derivedAndType(tp: AndType, tp1: Type, tp2: Type): Type =
       if (isRange(tp1) || isRange(tp2)) range(lower(tp1) & lower(tp2), upper(tp1) & upper(tp2))
       else tp.derivedAndType(tp1, tp2)
 
-    override protected def derivedOrType(tp: OrType, tp1: Type, tp2: Type) =
+    override protected def derivedOrType(tp: OrType, tp1: Type, tp2: Type): Type =
       if (isRange(tp1) || isRange(tp2)) range(lower(tp1) | lower(tp2), upper(tp1) | upper(tp2))
       else tp.derivedOrType(tp1, tp2)
 
-    override protected def derivedAnnotatedType(tp: AnnotatedType, underlying: Type, annot: Annotation) =
+    override protected def derivedAnnotatedType(tp: AnnotatedType, underlying: Type, annot: Annotation): Type =
       underlying match {
         case Range(lo, hi) =>
           range(tp.derivedAnnotatedType(lo, annot), tp.derivedAnnotatedType(hi, annot))
@@ -4596,7 +4592,7 @@ object Types {
           if (underlying.isBottomType) underlying
           else tp.derivedAnnotatedType(underlying, annot)
       }
-    override protected def derivedWildcardType(tp: WildcardType, bounds: Type) = {
+    override protected def derivedWildcardType(tp: WildcardType, bounds: Type): WildcardType = {
       tp.derivedWildcardType(rangeToBounds(bounds))
     }
 
@@ -4634,13 +4630,13 @@ object Types {
   abstract class TypeAccumulator[T](implicit protected val ctx: Context)
   extends VariantTraversal with ((T, Type) => T) {
 
-    protected def stopAtStatic = true
+    protected def stopAtStatic: Boolean = true
 
     def apply(x: T, tp: Type): T
 
     protected def applyToAnnot(x: T, annot: Annotation): T = x // don't go into annotations
 
-    protected final def applyToPrefix(x: T, tp: NamedType) =
+    protected final def applyToPrefix(x: T, tp: NamedType): T =
       atVariance(variance max 0)(this(x, tp.prefix)) // see remark on NamedType case in TypeMap
 
     def foldOver(x: T, tp: Type): T = {
@@ -4748,12 +4744,12 @@ object Types {
   abstract class TypeTraverser(implicit ctx: Context) extends TypeAccumulator[Unit] {
     def traverse(tp: Type): Unit
     def apply(x: Unit, tp: Type): Unit = traverse(tp)
-    protected def traverseChildren(tp: Type) = foldOver((), tp)
+    protected def traverseChildren(tp: Type): Unit = foldOver((), tp)
   }
 
   class ExistsAccumulator(p: Type => Boolean, forceLazy: Boolean = true)(implicit ctx: Context) extends TypeAccumulator[Boolean] {
-    override def stopAtStatic = false
-    def apply(x: Boolean, tp: Type) =
+    override def stopAtStatic: Boolean = false
+    def apply(x: Boolean, tp: Type): Boolean =
       x || p(tp) || (forceLazy || !tp.isInstanceOf[LazyRef]) && foldOver(x, tp)
   }
 
@@ -4763,9 +4759,9 @@ object Types {
 
   class NamedPartsAccumulator(p: NamedType => Boolean, excludeLowerBounds: Boolean = false)
     (implicit ctx: Context) extends TypeAccumulator[mutable.Set[NamedType]] {
-    override def stopAtStatic = false
-    def maybeAdd(x: mutable.Set[NamedType], tp: NamedType) = if (p(tp)) x += tp else x
-    val seen = new util.HashSet[Type](64) {
+    override def stopAtStatic: Boolean = false
+    def maybeAdd(x: mutable.Set[NamedType], tp: NamedType): mutable.Set[NamedType] = if (p(tp)) x += tp else x
+    val seen: util.HashSet[Type] = new util.HashSet[Type](64) {
       override def hash(x: Type): Int = System.identityHashCode(x)
       override def isEqual(x: Type, y: Type) = x.eq(y)
     }
@@ -4798,7 +4794,7 @@ object Types {
   }
 
   class isGroundAccumulator(implicit ctx: Context) extends TypeAccumulator[Boolean] {
-    def apply(x: Boolean, tp: Type) = x && {
+    def apply(x: Boolean, tp: Type): Boolean = x && {
       tp match {
         case _: TypeParamRef => false
         case tp: TypeVar => apply(x, tp.underlying)
@@ -4877,12 +4873,12 @@ object Types {
 
   // ----- Debug ---------------------------------------------------------
 
-  @sharable var debugTrace = false
+  @sharable var debugTrace: Boolean = false
 
-  val watchList = List[String](
+  val watchList: List[TypeName] = List[String](
   ) map (_.toTypeName)
 
-  def isWatched(tp: Type)(implicit ctx: Context) = tp match {
+  def isWatched(tp: Type)(implicit ctx: Context): Boolean = tp match {
     case ref: TypeRef => watchList contains ref.name
     case _ => false
   }
diff --git a/compiler/src/dotty/tools/dotc/core/Uniques.scala b/compiler/src/dotty/tools/dotc/core/Uniques.scala
index f31dc4f389b8..1bb6db5baeec 100644
--- a/compiler/src/dotty/tools/dotc/core/Uniques.scala
+++ b/compiler/src/dotty/tools/dotc/core/Uniques.scala
@@ -1,7 +1,7 @@
 package dotty.tools.dotc
 package core
 
-import Types._, Symbols._, Contexts._, util.Stats._, Hashable._, Names._
+import Types._, Contexts._, util.Stats._, Hashable._, Names._
 import config.Config
 import Decorators._
 import util.HashSet
diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileConstants.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileConstants.scala
index 9c517d6ef8db..02cebe2541ab 100644
--- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileConstants.scala
+++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileConstants.scala
@@ -334,7 +334,7 @@ object ClassfileConstants {
   import Flags._
   abstract class FlagTranslation {
 
-    protected def baseFlags(jflags: Int) = EmptyFlags
+    protected def baseFlags(jflags: Int): FlagSet = EmptyFlags
     protected def isClass: Boolean = false
 
     private def translateFlag(jflag: Int): FlagSet = (jflag: @switch) match {
@@ -368,13 +368,13 @@ object ClassfileConstants {
 
     def flags(jflags: Int): FlagSet = translateFlags(jflags, baseFlags(jflags))
   }
-  val classTranslation = new FlagTranslation {
+  val classTranslation: FlagTranslation = new FlagTranslation {
     override def isClass = true
   }
-  val fieldTranslation = new FlagTranslation {
+  val fieldTranslation: FlagTranslation = new FlagTranslation {
     override def baseFlags(jflags: Int) = if ((jflags & JAVA_ACC_FINAL) == 0) Mutable else EmptyFlags
   }
-  val methodTranslation = new FlagTranslation {
+  val methodTranslation: FlagTranslation = new FlagTranslation {
     override def baseFlags(jflags: Int) = if ((jflags & JAVA_ACC_BRIDGE) != 0) Bridge else EmptyFlags
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
index 4c908c712941..3f9d75334c74 100644
--- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
+++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -18,7 +18,7 @@ import scala.collection.immutable
 import scala.collection.mutable.{ ListBuffer, ArrayBuffer }
 import scala.annotation.switch
 import typer.Checking.checkNonCyclic
-import io.{AbstractFile, PlainFile, Path, ZipArchive, JarArchive}
+import io.{AbstractFile, PlainFile, ZipArchive}
 import scala.util.control.NonFatal
 
 object ClassfileParser {
@@ -30,7 +30,7 @@ object ClassfileParser {
   object NoEmbedded extends Embedded
 
   /** Replace raw types with wildcard applications */
-  def cook(implicit ctx: Context) = new TypeMap {
+  def cook(implicit ctx: Context): TypeMap = new TypeMap {
     def apply(tp: Type): Type = tp match {
       case tp: TypeRef if tp.symbol.typeParams.nonEmpty =>
         AppliedType(tp, tp.symbol.typeParams.map(Function.const(TypeBounds.empty)))
@@ -59,7 +59,7 @@ class ClassfileParser(
   import ClassfileConstants._
   import ClassfileParser._
 
-  protected val in = new AbstractFileReader(classfile)
+  protected val in: AbstractFileReader = new AbstractFileReader(classfile)
 
   protected val staticModule: Symbol = moduleRoot.sourceModule(ictx)
 
@@ -68,7 +68,7 @@ class ClassfileParser(
   protected var pool: ConstantPool = _              // the classfile's constant pool
 
   protected var currentClassName: SimpleName = _      // JVM name of the current class
-  protected var classTParams = Map[Name,Symbol]()
+  protected var classTParams: Map[Name, Symbol] = Map()
 
   private[this] var Scala2UnpicklingMode = Mode.Scala2Unpickling
 
@@ -114,7 +114,7 @@ class ClassfileParser(
     case None => ctx.requiredClass(name)
   }
 
-  var sawPrivateConstructor = false
+  var sawPrivateConstructor: Boolean = false
 
   def parseClass()(implicit ctx: Context): Option[Embedded] = {
     val jflags       = in.nextChar
@@ -225,7 +225,7 @@ class ClassfileParser(
     skipAttributes()
   }
 
-  val memberCompleter = new LazyType {
+  val memberCompleter: LazyType = new LazyType {
 
     def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
       val oldbp = in.bp
@@ -292,7 +292,7 @@ class ClassfileParser(
   }
 
   /** Map direct references to Object to references to Any */
-  final def objToAny(tp: Type)(implicit ctx: Context) =
+  final def objToAny(tp: Type)(implicit ctx: Context): Type =
     if (tp.isDirectRef(defn.ObjectClass) && !ctx.phase.erasedTypes) defn.AnyType else tp
 
   private def sigToType(sig: SimpleName, owner: Symbol = null)(implicit ctx: Context): Type = {
@@ -903,11 +903,11 @@ class ClassfileParser(
 
   /** An entry in the InnerClasses attribute of this class file. */
   case class InnerClassEntry(external: Int, outer: Int, name: Int, jflags: Int) {
-    def externalName = pool.getClassName(external)
-    def outerName    = pool.getClassName(outer)
-    def originalName = pool.getName(name)
+    def externalName: SimpleName = pool.getClassName(external)
+    def outerName: SimpleName    = pool.getClassName(outer)
+    def originalName: SimpleName = pool.getName(name)
 
-    override def toString =
+    override def toString: String =
       originalName + " in " + outerName + "(" + externalName + ")"
   }
 
diff --git a/compiler/src/dotty/tools/dotc/core/quoted/QuoteUnpickler.scala b/compiler/src/dotty/tools/dotc/core/quoted/QuoteUnpickler.scala
index af171d0eceb0..7a01d611a94b 100644
--- a/compiler/src/dotty/tools/dotc/core/quoted/QuoteUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/quoted/QuoteUnpickler.scala
@@ -7,7 +7,7 @@ import dotty.tools.dotc.core.tasty.TreeUnpickler.UnpickleMode
 object QuoteUnpickler {
   class QuotedTreeSectionUnpickler(posUnpickler: Option[PositionUnpickler], splices: Seq[Any])
     extends DottyUnpickler.TreeSectionUnpickler(posUnpickler, None) {
-    override def unpickle(reader: TastyReader, nameAtRef: NameTable) =
+    override def unpickle(reader: TastyReader, nameAtRef: NameTable): TreeUnpickler =
       new TreeUnpickler(reader, nameAtRef, posUnpickler, None, splices)
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/CommentUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/CommentUnpickler.scala
index 7d4e48cbcd18..0dfe01f6ea12 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/CommentUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/CommentUnpickler.scala
@@ -1,7 +1,6 @@
 package dotty.tools.dotc.core.tasty
 
 import dotty.tools.dotc.core.Comments.Comment
-import dotty.tools.dotc.core.Symbols.Symbol
 import dotty.tools.dotc.core.tasty.TastyBuffer.Addr
 import dotty.tools.dotc.util.Positions.Position
 
@@ -12,7 +11,7 @@ import java.nio.charset.Charset
 class CommentUnpickler(reader: TastyReader) {
   import reader._
 
-  private[tasty] lazy val comments = {
+  private[tasty] lazy val comments: Map[Addr, Comment] = {
     val comments = new HashMap[Addr, Comment]
     while (!isAtEnd) {
       val addr = readAddr()
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala
index 1c9acee3ba39..fdb003a8a181 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/DottyUnpickler.scala
@@ -3,12 +3,9 @@ package dotc
 package core
 package tasty
 
-import Contexts._, SymDenotations._, Symbols._,  Decorators._
+import Contexts._, SymDenotations._,  Decorators._
 import dotty.tools.dotc.ast.tpd
-import TastyUnpickler._, TastyBuffer._
-import util.Positions._
-import util.{SourceFile, NoSource}
-import Annotations.Annotation
+import TastyUnpickler._
 import classfile.ClassfileParser
 import Names.SimpleName
 import TreeUnpickler.UnpickleMode
@@ -20,12 +17,12 @@ object DottyUnpickler {
 
   class TreeSectionUnpickler(posUnpickler: Option[PositionUnpickler], commentUnpickler: Option[CommentUnpickler])
   extends SectionUnpickler[TreeUnpickler]("ASTs") {
-    def unpickle(reader: TastyReader, nameAtRef: NameTable) =
+    def unpickle(reader: TastyReader, nameAtRef: NameTable): TreeUnpickler =
       new TreeUnpickler(reader, nameAtRef, posUnpickler, commentUnpickler, Seq.empty)
   }
 
   class PositionsSectionUnpickler extends SectionUnpickler[PositionUnpickler]("Positions") {
-    def unpickle(reader: TastyReader, nameAtRef: NameTable) =
+    def unpickle(reader: TastyReader, nameAtRef: NameTable): PositionUnpickler =
       new PositionUnpickler(reader)
   }
 
@@ -43,7 +40,7 @@ class DottyUnpickler(bytes: Array[Byte], mode: UnpickleMode = UnpickleMode.TopLe
   import tpd._
   import DottyUnpickler._
 
-  val unpickler = new TastyUnpickler(bytes)
+  val unpickler: TastyUnpickler = new TastyUnpickler(bytes)
   private val posUnpicklerOpt = unpickler.unpickle(new PositionsSectionUnpickler)
   private val commentUnpicklerOpt = unpickler.unpickle(new CommentsSectionUnpickler)
   private val treeUnpickler = unpickler.unpickle(treeSectionUnpickler(posUnpicklerOpt, commentUnpicklerOpt)).get
@@ -61,7 +58,7 @@ class DottyUnpickler(bytes: Array[Byte], mode: UnpickleMode = UnpickleMode.TopLe
     new TreeSectionUnpickler(posUnpicklerOpt, commentUnpicklerOpt)
   }
 
-  protected def computeRootTrees(implicit ctx: Context) = treeUnpickler.unpickle(mode)
+  protected def computeRootTrees(implicit ctx: Context): List[Tree] = treeUnpickler.unpickle(mode)
 
   private[this] var ids: Array[String] = null
 
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala b/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala
index df83b8d50573..edab7045095a 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/NameBuffer.scala
@@ -5,12 +5,10 @@ package tasty
 
 import collection.mutable
 import Names.{Name, chrs, SimpleName, DerivedName}
-import NameOps.NameDecorator
 import NameKinds._
 import Decorators._
 import TastyBuffer._
 import scala.io.Codec
-import TastyFormat._
 
 class NameBuffer extends TastyBuffer(10000) {
   import NameBuffer._
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/PositionPickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/PositionPickler.scala
index c3aa124928ae..2af9e393500b 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/PositionPickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/PositionPickler.scala
@@ -6,27 +6,25 @@ package tasty
 import ast._
 import ast.Trees._
 import ast.Trees.WithLazyField
-import TastyFormat._
 import core._
-import Contexts._, Symbols._, Types._, Names._, Constants._, Decorators._, Annotations._
+import Contexts._, Symbols._, Annotations._
 import collection.mutable
 import TastyBuffer._
 import util.Positions._
 
 class PositionPickler(pickler: TastyPickler, addrOfTree: untpd.Tree => Option[Addr]) {
-  val buf = new TastyBuffer(5000)
+  val buf: TastyBuffer = new TastyBuffer(5000)
   pickler.newSection("Positions", buf)
-  import buf._
   import ast.tpd._
 
   private val pickledIndices = new mutable.BitSet
 
-  def header(addrDelta: Int, hasStartDelta: Boolean, hasEndDelta: Boolean, hasPoint: Boolean) = {
+  def header(addrDelta: Int, hasStartDelta: Boolean, hasEndDelta: Boolean, hasPoint: Boolean): Int = {
     def toInt(b: Boolean) = if (b) 1 else 0
     (addrDelta << 3) | (toInt(hasStartDelta) << 2) | (toInt(hasEndDelta) << 1) | toInt(hasPoint)
   }
 
-  def picklePositions(roots: List[Tree])(implicit ctx: Context) = {
+  def picklePositions(roots: List[Tree])(implicit ctx: Context): Unit = {
     var lastIndex = 0
     var lastPos = Position(0, 0)
     def pickleDeltas(index: Int, pos: Position) = {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/PositionUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/PositionUnpickler.scala
index cbe213d89aae..1e1031cb9e6f 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/PositionUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/PositionUnpickler.scala
@@ -3,16 +3,15 @@ package dotc
 package core
 package tasty
 
-
 import util.Positions._
-import collection.mutable
-import TastyBuffer.{Addr, NoAddr}
+import collection.{mutable, Map}
+import TastyBuffer.Addr
 
 /** Unpickler for tree positions */
 class PositionUnpickler(reader: TastyReader) {
   import reader._
 
-  private[tasty] lazy val positions = {
+  private[tasty] lazy val positions: Map[Addr, Position] = {
     val positions = new mutable.HashMap[Addr, Position]
     var curIndex = 0
     var curStart = 0
@@ -27,13 +26,13 @@ class PositionUnpickler(reader: TastyReader) {
       assert(curIndex >= 0)
       if (hasStart) curStart += readInt()
       if (hasEnd) curEnd += readInt()
-      positions(Addr(curIndex)) = 
+      positions(Addr(curIndex)) =
         if (hasPoint) Position(curStart, curEnd, curStart + readInt())
         else Position(curStart, curEnd)
     }
     positions
   }
 
-  def posAt(addr: Addr) = positions.getOrElse(addr, NoPosition)
+  def posAt(addr: Addr): Position = positions.getOrElse(addr, NoPosition)
 }
 
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyBuffer.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyBuffer.scala
index 4c092c22e56d..e494b4381186 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyBuffer.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyBuffer.scala
@@ -22,7 +22,7 @@ object TastyBuffer {
     def relativeTo(base: Addr): Addr = this - base.index - AddrWidth
   }
 
-  val NoAddr = Addr(-1)
+  val NoAddr: Addr = Addr(-1)
 
   /** The maximal number of address bytes.
    *  Since addresses are written as base-128 natural numbers,
@@ -41,10 +41,10 @@ import TastyBuffer._
 class TastyBuffer(initialSize: Int) {
 
   /** The current byte array, will be expanded as needed */
-  var bytes = new Array[Byte](initialSize)
+  var bytes: Array[Byte] = new Array(initialSize)
 
   /** The number of bytes written */
-  var length = 0
+  var length: Int = 0
 
   // -- Output routines --------------------------------------------
 
@@ -155,7 +155,7 @@ class TastyBuffer(initialSize: Int) {
   }
 
   /** The address (represented as a natural number) at address `at` */
-  def getAddr(at: Addr) = Addr(getNat(at))
+  def getAddr(at: Addr): Addr = Addr(getNat(at))
 
   /** The smallest address equal to or following `at` which points to a non-zero byte */
   final def skipZeroes(at: Addr): Addr =
@@ -178,7 +178,7 @@ class TastyBuffer(initialSize: Int) {
   }
 
   /** Fill reserved space at address `at` with address `target` */
-  def fillAddr(at: Addr, target: Addr) =
+  def fillAddr(at: Addr, target: Addr): Unit =
     putNat(at, target.index, AddrWidth)
 
   /** Write address without leading zeroes */
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
index 9094a416de87..b59a7fb02ecf 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
@@ -235,9 +235,9 @@ Standard Section: "Comments" Comment*
 
 object TastyFormat {
 
-  final val header = Array(0x5C, 0xA1, 0xAB, 0x1F)
-  val MajorVersion = 11
-  val MinorVersion = 0
+  final val header: Array[Int] = Array(0x5C, 0xA1, 0xAB, 0x1F)
+  val MajorVersion: Int = 11
+  val MinorVersion: Int = 0
 
   /** Tags used to serialize names */
   class NameTags {
@@ -425,7 +425,7 @@ object TastyFormat {
   final val MATCHtype = 190
   final val MATCHtpt = 191
 
-  def methodType(isImplicit: Boolean = false, isErased: Boolean = false) = {
+  def methodType(isImplicit: Boolean = false, isErased: Boolean = false): Int = {
     val implicitOffset = if (isImplicit) 1 else 0
     val erasedOffset = if (isErased) 2 else 0
     METHODtype + implicitOffset + erasedOffset
@@ -439,7 +439,7 @@ object TastyFormat {
   final val firstLengthTreeTag = PACKAGE
 
   /** Useful for debugging */
-  def isLegalTag(tag: Int) =
+  def isLegalTag(tag: Int): Boolean =
     firstSimpleTreeTag <= tag && tag <= PARAMsetter ||
     firstNatTreeTag <= tag && tag <= SYMBOLconst ||
     firstASTTreeTag <= tag && tag <= SINGLETONtpt ||
@@ -447,9 +447,9 @@ object TastyFormat {
     firstLengthTreeTag <= tag && tag <= MATCHtpt ||
     tag == HOLE
 
-  def isParamTag(tag: Int) = tag == PARAM || tag == TYPEPARAM
+  def isParamTag(tag: Int): Boolean = tag == PARAM || tag == TYPEPARAM
 
-  def isModifierTag(tag: Int) = tag match {
+  def isModifierTag(tag: Int): Boolean = tag match {
     case PRIVATE
        | INTERNAL
        | PROTECTED
@@ -486,7 +486,7 @@ object TastyFormat {
     case _ => false
   }
 
-  def isTypeTreeTag(tag: Int) = tag match {
+  def isTypeTreeTag(tag: Int): Boolean = tag match {
     case IDENTtpt
        | SELECTtpt
        | SINGLETONtpt
@@ -645,7 +645,7 @@ object TastyFormat {
   /** @return If non-negative, the number of leading references (represented as nats) of a length/trees entry.
    *          If negative, minus the number of leading non-reference trees.
    */
-  def numRefs(tag: Int) = tag match {
+  def numRefs(tag: Int): Int = tag match {
     case VALDEF | DEFDEF | TYPEDEF | OBJECTDEF | TYPEPARAM | PARAM | NAMEDARG | RETURN | BIND |
          SELFDEF | REFINEDtype | TERMREFin | TYPEREFin | HOLE => 1
     case RENAMED | PARAMtype => 2
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyPickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyPickler.scala
index d7e1ddf0d42f..b51af96b9720 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyPickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyPickler.scala
@@ -14,9 +14,9 @@ class TastyPickler(val rootCls: ClassSymbol) {
 
   private val sections = new mutable.ArrayBuffer[(NameRef, TastyBuffer)]
 
-  val nameBuffer = new NameBuffer
+  val nameBuffer: NameBuffer = new NameBuffer
 
-  def newSection(name: String, buf: TastyBuffer) =
+  def newSection(name: String, buf: TastyBuffer): Unit =
     sections += ((nameBuffer.nameIndex(name.toTermName), buf))
 
   def assembleParts(): Array[Byte] = {
@@ -76,6 +76,6 @@ class TastyPickler(val rootCls: ClassSymbol) {
    */
   var addrOfSym: Symbol => Option[Addr] = (_ => None)
 
-  val treePkl = new TreePickler(this)
+  val treePkl: TreePickler = new TreePickler(this)
 
 }
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
index 65724cfd8142..4bd53cdb8d2f 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
@@ -3,25 +3,22 @@ package core
 package tasty
 
 import Contexts._, Decorators._
-import printing.Texts._
 import Names.Name
-import StdNames._
 import TastyUnpickler._
-import TastyBuffer.{Addr, NameRef}
-import util.Positions.{Position, offsetToInt}
-import collection.mutable
+import TastyBuffer.NameRef
+import util.Positions.offsetToInt
 import printing.Highlighting._
 
 class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
 
-  val unpickler = new TastyUnpickler(bytes)
+  val unpickler: TastyUnpickler = new TastyUnpickler(bytes)
   import unpickler.{nameAtRef, unpickle}
 
   def nameToString(name: Name): String = name.debugString
 
   def nameRefToString(ref: NameRef): String = nameToString(nameAtRef(ref))
 
-  def printNames() =
+  def printNames(): Unit =
     for ((name, idx) <- nameAtRef.contents.zipWithIndex) {
       val index = nameColor("%4d".format(idx))
       println(index + ": " + nameToString(name))
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyReader.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyReader.scala
index 938c85e10d1c..b90546d61d47 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyReader.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyReader.scala
@@ -20,8 +20,8 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int =
 
   private[this] var bp: Int = start
 
-  def addr(idx: Int) = Addr(idx - base)
-  def index(addr: Addr) = addr.index + base
+  def addr(idx: Int): Addr = Addr(idx - base)
+  def index(addr: Addr): Int = addr.index + base
 
   /** The address of the first byte to read, respectively byte that was read */
   def startAddr: Addr = addr(start)
@@ -105,10 +105,10 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int =
   }
 
   /** Read a natural number and return as a NameRef */
-  def readNameRef() = NameRef(readNat())
+  def readNameRef(): NameRef = NameRef(readNat())
 
   /** Read a natural number and return as an address */
-  def readAddr() = Addr(readNat())
+  def readAddr(): Addr = Addr(readNat())
 
   /** Read a length number and return the absolute end address implied by it,
    *  given as <address following length field> + <length-value-read>.
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyUnpickler.scala
index 94dd7f4b8120..a849b467f7e7 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyUnpickler.scala
@@ -3,12 +3,10 @@ package core
 package tasty
 
 import scala.collection.mutable
-import TastyFormat._
 import TastyFormat.NameTags._
 import TastyBuffer.NameRef
-import Names.{Name, TermName, termName, EmptyTermName}
+import Names.{TermName, termName, EmptyTermName}
 import NameKinds._
-import java.util.UUID
 
 object TastyUnpickler {
   class UnpickleException(msg: String) extends RuntimeException(msg)
@@ -19,8 +17,8 @@ object TastyUnpickler {
 
   class NameTable extends (NameRef => TermName) {
     private val names = new mutable.ArrayBuffer[TermName]
-    def add(name: TermName) = names += name
-    def apply(ref: NameRef) = names(ref.index)
+    def add(name: TermName): mutable.ArrayBuffer[TermName] = names += name
+    def apply(ref: NameRef): TermName = names(ref.index)
     def contents: Iterable[TermName] = names
   }
 }
@@ -33,7 +31,7 @@ class TastyUnpickler(reader: TastyReader) {
   def this(bytes: Array[Byte]) = this(new TastyReader(bytes))
 
   private val sectionReader = new mutable.HashMap[String, TastyReader]
-  val nameAtRef = new NameTable
+  val nameAtRef: NameTable = new NameTable
 
   private def readName(): TermName = nameAtRef(readNameRef())
   private def readString(): String = readName().toString
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeBuffer.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeBuffer.scala
index 5fd72acc8816..8afedec37b2b 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeBuffer.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeBuffer.scala
@@ -51,13 +51,13 @@ class TreeBuffer extends TastyBuffer(50000) {
   }
 
   /** Write reference right adjusted into freshly reserved field. */
-  def writeRef(target: Addr) = {
+  def writeRef(target: Addr): Unit = {
     keepOffset(relative = false)
     fillAddr(reserveAddr(), target)
   }
 
   /** Fill previously reserved field with a reference */
-  def fillRef(at: Addr, target: Addr, relative: Boolean) = {
+  def fillRef(at: Addr, target: Addr, relative: Boolean): Unit = {
     val addr = if (relative) target.relativeTo(at) else target
     fillAddr(at, addr)
   }
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index d2431cfb01f2..468332513ae3 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -4,19 +4,16 @@ package core
 package tasty
 
 import ast.Trees._
-import ast.{untpd, tpd, desugar}
+import ast.{untpd, tpd}
 import TastyFormat._
-import Contexts._, Symbols._, Types._, Names._, Constants._, Decorators._, Annotations._, StdNames.tpnme, NameOps._
-import collection.mutable
+import Contexts._, Symbols._, Types._, Names._, Constants._, Decorators._, Annotations._, Flags._
 import typer.Inliner
-import NameOps._, NameKinds._
+import NameKinds._
 import StdNames.nme
 import TastyBuffer._
-import TypeApplications._
 import transform.SymUtils._
 import printing.Printer
 import printing.Texts._
-import config.Config
 
 object TreePickler {
 
@@ -27,7 +24,7 @@ object TreePickler {
 }
 
 class TreePickler(pickler: TastyPickler) {
-  val buf = new TreeBuffer
+  val buf: TreeBuffer = new TreeBuffer
   pickler.newSection("ASTs", buf)
   import TreePickler._
   import buf._
@@ -265,7 +262,7 @@ class TreePickler(pickler: TastyPickler) {
       pickleType(tpe.ref)
   }
 
-  def pickleMethodic(tag: Int, tpe: LambdaType)(implicit ctx: Context) = {
+  def pickleMethodic(tag: Int, tpe: LambdaType)(implicit ctx: Context): Unit = {
     writeByte(tag)
     withLength {
       pickleType(tpe.resultType, richTypes = true)
@@ -291,7 +288,7 @@ class TreePickler(pickler: TastyPickler) {
   def pickleTreeUnlessEmpty(tree: Tree)(implicit ctx: Context): Unit =
     if (!tree.isEmpty) pickleTree(tree)
 
-  def pickleDef(tag: Int, sym: Symbol, tpt: Tree, rhs: Tree = EmptyTree, pickleParams: => Unit = ())(implicit ctx: Context) = {
+  def pickleDef(tag: Int, sym: Symbol, tpt: Tree, rhs: Tree = EmptyTree, pickleParams: => Unit = ())(implicit ctx: Context): Unit = {
     assert(symRefs(sym) == NoAddr, sym)
     registerDef(sym)
     writeByte(tag)
@@ -321,7 +318,7 @@ class TreePickler(pickler: TastyPickler) {
     trees.foreach(pickleParam)
   }
 
-  def pickleStats(stats: List[Tree])(implicit ctx: Context) = {
+  def pickleStats(stats: List[Tree])(implicit ctx: Context): Unit = {
     stats.foreach(preRegister)
     stats.foreach(stat => if (!stat.isEmpty) pickleTree(stat))
   }
@@ -614,7 +611,7 @@ class TreePickler(pickler: TastyPickler) {
     sym.annotations.foreach(pickleAnnotation(sym, _))
   }
 
-  def pickleFlags(flags: Flags.FlagSet, isTerm: Boolean)(implicit ctx: Context): Unit = {
+  def pickleFlags(flags: FlagSet, isTerm: Boolean)(implicit ctx: Context): Unit = {
     import Flags._
     if (flags is Private) writeByte(PRIVATE)
     if (flags is Protected) writeByte(PROTECTED)
@@ -663,7 +660,7 @@ class TreePickler(pickler: TastyPickler) {
       else false
   }
 
-  def pickleAnnotation(owner: Symbol, ann: Annotation)(implicit ctx: Context) =
+  def pickleAnnotation(owner: Symbol, ann: Annotation)(implicit ctx: Context): Unit =
     if (!isUnpicklable(owner, ann)) {
       writeByte(ANNOTATION)
       withLength { pickleType(ann.symbol.typeRef); pickleTree(ann.tree) }
@@ -671,13 +668,13 @@ class TreePickler(pickler: TastyPickler) {
 
 // ---- main entry points ---------------------------------------
 
-  def pickle(trees: List[Tree])(implicit ctx: Context) = {
+  def pickle(trees: List[Tree])(implicit ctx: Context): Unit = {
     trees.foreach(tree => if (!tree.isEmpty) pickleTree(tree))
     def missing = forwardSymRefs.keysIterator.map(_.showLocated).toList
     assert(forwardSymRefs.isEmpty, i"unresolved symbols: $missing%, % when pickling ${ctx.source}")
   }
 
-  def compactify() = {
+  def compactify(): Unit = {
     buf.compactify()
 
     def updateMapWithDeltas(mp: MutableSymbolMap[Addr]) =
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 3058fdcf929c..51528469a826 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -5,7 +5,7 @@ package tasty
 
 import Comments.CommentsContext
 import Contexts._, Symbols._, Types._, Scopes._, SymDenotations._, Names._, NameOps._
-import StdNames._, Denotations._, Flags._, Constants._, Annotations._
+import StdNames._, Flags._, Constants._, Annotations._
 import NameKinds._
 import typer.Checking.checkNonCyclic
 import util.Positions._
@@ -13,13 +13,11 @@ import ast.{tpd, untpd, Trees}
 import Trees._
 import Decorators._
 import transform.SymUtils._
-import TastyUnpickler._, TastyBuffer._
+import TastyBuffer._
 import scala.annotation.{tailrec, switch}
 import scala.collection.mutable.ListBuffer
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 import config.Printers.pickling
-import typer.Checking
-import config.Config
 import core.quoted.PickledQuotes
 import scala.quoted
 import scala.quoted.Types.TreeType
@@ -115,8 +113,8 @@ class TreeUnpickler(reader: TastyReader,
   class TreeReader(val reader: TastyReader) {
     import reader._
 
-    def forkAt(start: Addr) = new TreeReader(subReader(start, endAddr))
-    def fork = forkAt(currentAddr)
+    def forkAt(start: Addr): TreeReader = new TreeReader(subReader(start, endAddr))
+    def fork: TreeReader = forkAt(currentAddr)
 
     def skipTree(tag: Int): Unit =
       if (tag >= firstLengthTreeTag) goto(readEnd())
@@ -700,7 +698,7 @@ class TreeUnpickler(reader: TastyReader,
     /** Create symbols the longest consecutive sequence of parameters with given
      *  `tag` starting at current address.
      */
-    def indexParams(tag: Int)(implicit ctx: Context) =
+    def indexParams(tag: Int)(implicit ctx: Context): Unit =
       while (nextByte == tag) {
         symbolAtCurrent()
         skipTree()
@@ -709,7 +707,7 @@ class TreeUnpickler(reader: TastyReader,
     /** Create symbols for all type and value parameters of template starting
      *  at current address.
      */
-    def indexTemplateParams()(implicit ctx: Context) = {
+    def indexTemplateParams()(implicit ctx: Context): Unit = {
       assert(readByte() == TEMPLATE)
       readEnd()
       indexParams(TYPEPARAM)
@@ -1323,7 +1321,7 @@ class TreeUnpickler(reader: TastyReader,
       }
     }
 
-    override def toString =
+    override def toString: String =
       s"OwnerTree(${addr.index}, ${end.index}, ${if (myChildren == null) "?" else myChildren.mkString(" ")})"
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/PickleBuffer.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/PickleBuffer.scala
index 31f05cf71f4e..f96d3348ec11 100644
--- a/compiler/src/dotty/tools/dotc/core/unpickleScala2/PickleBuffer.scala
+++ b/compiler/src/dotty/tools/dotc/core/unpickleScala2/PickleBuffer.scala
@@ -13,9 +13,9 @@ import Flags._
  */
 class PickleBuffer(data: Array[Byte], from: Int, to: Int) {
 
-  var bytes = data
-  var readIndex = from
-  var writeIndex = to
+  var bytes: Array[Byte] = data
+  var readIndex: Int = from
+  var writeIndex: Int = to
 
   /** Double bytes array */
   private def dble(): Unit = {
@@ -24,7 +24,7 @@ class PickleBuffer(data: Array[Byte], from: Int, to: Int) {
     bytes = bytes1
   }
 
-  def ensureCapacity(capacity: Int) =
+  def ensureCapacity(capacity: Int): Unit =
     while (bytes.length < writeIndex + capacity) dble()
 
   // -- Basic output routines --------------------------------------------
diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/PickleFormat.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/PickleFormat.scala
index a8855545f859..f50e53d6b882 100644
--- a/compiler/src/dotty/tools/dotc/core/unpickleScala2/PickleFormat.scala
+++ b/compiler/src/dotty/tools/dotc/core/unpickleScala2/PickleFormat.scala
@@ -116,8 +116,8 @@ object PickleFormat {
  *
  *   len is remaining length after `len`.
  */
-  val MajorVersion = 5
-  val MinorVersion = 0
+  val MajorVersion: Int = 5
+  val MinorVersion: Int = 0
 
   final val TERMname = 1
   final val TYPEname = 2
diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Flags.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Flags.scala
index 97480e49ff4a..5025a7a54997 100644
--- a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Flags.scala
+++ b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Flags.scala
@@ -8,7 +8,6 @@ package dotc
 package core
 package unpickleScala2
 
-import scala.collection.{ mutable, immutable }
 
 /** Scala2 flags, adapted from https://github.com/scala/scala/blob/2.11.x/src/reflect/scala/reflect/internal/Flags.scala
  */
diff --git a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
index 24d7606c2b9b..fc9bce38c7fd 100644
--- a/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala
@@ -10,9 +10,8 @@ import java.lang.Double.longBitsToDouble
 import Contexts._, Symbols._, Types._, Scopes._, SymDenotations._, Names._, NameOps._
 import StdNames._, Denotations._, NameOps._, Flags._, Constants._, Annotations._
 import NameKinds.{Scala2MethodNameKinds, SuperAccessorName, ExpandedName}
-import dotty.tools.dotc.typer.ProtoTypes.{FunProtoTyped, FunProto}
 import util.Positions._
-import dotty.tools.dotc.ast.{tpd, Trees, untpd}, ast.tpd._
+import dotty.tools.dotc.ast.{tpd, untpd}, ast.tpd._
 import ast.untpd.Modifiers
 import printing.Texts._
 import printing.Printer
@@ -25,7 +24,7 @@ import PickleFormat._
 import Decorators._
 import TypeApplications._
 import classfile.ClassfileParser
-import scala.collection.{ mutable, immutable }
+import scala.collection.mutable
 import scala.collection.mutable.ListBuffer
 import scala.annotation.switch
 import reporting.trace
@@ -52,7 +51,7 @@ object Scala2Unpickler {
     case tp => tp
   }
 
-  def addConstructorTypeParams(denot: SymDenotation)(implicit ctx: Context) = {
+  def addConstructorTypeParams(denot: SymDenotation)(implicit ctx: Context): Unit = {
     assert(denot.isConstructor)
     denot.info = PolyType.fromParams(denot.owner.typeParams, denot.info)
   }
@@ -85,7 +84,7 @@ object Scala2Unpickler {
       tp.derivedLambdaType(tp.paramNames, tp.paramInfos, arrayToRepeated(tp.resultType))
   }
 
-  def ensureConstructor(cls: ClassSymbol, scope: Scope)(implicit ctx: Context) =
+  def ensureConstructor(cls: ClassSymbol, scope: Scope)(implicit ctx: Context): Unit =
     if (scope.lookup(nme.CONSTRUCTOR) == NoSymbol) {
       val constr = ctx.newDefaultConstructor(cls)
       addConstructorTypeParams(constr)
@@ -148,7 +147,7 @@ object Scala2Unpickler {
 class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClassRoot: ClassDenotation)(ictx: Context)
   extends PickleBuffer(bytes, 0, -1) with ClassfileParser.Embedded {
 
-  def showPickled() = {
+  def showPickled(): Unit = {
     atReadPos(0, () => {
       println(s"classRoot = ${classRoot.debugString}, moduleClassRoot = ${moduleClassRoot.debugString}")
       util.ShowPickled.printFile(this)
@@ -159,7 +158,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
 
   import Scala2Unpickler._
 
-  val moduleRoot = moduleClassRoot.sourceModule(ictx).denot(ictx)
+  val moduleRoot: SymDenotation = moduleClassRoot.sourceModule(ictx).denot(ictx)
   assert(moduleRoot.isTerm)
 
   checkVersion(ictx)
@@ -175,7 +174,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
   /** A map from symbols to their associated `decls` scopes */
   private val symScopes = mutable.AnyRefMap[Symbol, Scope]()
 
-  protected def errorBadSignature(msg: String, original: Option[RuntimeException] = None)(implicit ctx: Context) = {
+  protected def errorBadSignature(msg: String, original: Option[RuntimeException] = None)(implicit ctx: Context): Nothing = {
     val ex = new BadSignature(
       i"""error reading Scala signature of $classRoot from $source:
          |error occurred at position $readIndex: $msg""")
@@ -183,12 +182,12 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     throw ex
   }
 
-  protected def handleRuntimeException(ex: RuntimeException)(implicit ctx: Context) = ex match {
+  protected def handleRuntimeException(ex: RuntimeException)(implicit ctx: Context): Nothing = ex match {
     case ex: BadSignature => throw ex
     case _ => errorBadSignature(s"a runtime exception occurred: $ex", Some(ex))
   }
 
-  def run()(implicit ctx: Context) =
+  def run()(implicit ctx: Context): Unit =
     try {
       var i = 0
       while (i < index.length) {
@@ -244,7 +243,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
   }
 
   /** The `decls` scope associated with given symbol */
-  protected def symScope(sym: Symbol) = symScopes.getOrElseUpdate(sym, newScope)
+  protected def symScope(sym: Symbol): Scope = symScopes.getOrElseUpdate(sym, newScope)
 
   /** Does entry represent an (internal) symbol */
   protected def isSymbolEntry(i: Int)(implicit ctx: Context): Boolean = {
@@ -295,9 +294,9 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
   protected def isRefinementClass(sym: Symbol)(implicit ctx: Context): Boolean =
     sym.name == tpnme.REFINE_CLASS
 
-  protected def isLocal(sym: Symbol)(implicit ctx: Context) = isUnpickleRoot(sym.topLevelClass)
+  protected def isLocal(sym: Symbol)(implicit ctx: Context): Boolean = isUnpickleRoot(sym.topLevelClass)
 
-  protected def isUnpickleRoot(sym: Symbol)(implicit ctx: Context) = {
+  protected def isUnpickleRoot(sym: Symbol)(implicit ctx: Context): Boolean = {
     val d = sym.denot
     d == moduleRoot || d == moduleClassRoot || d == classRoot
   }
@@ -606,13 +605,13 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
       atReadPos(index(infoRef), () => readTypeParams()(ctx))
 
     /** Force reading type params early, we need them in setClassInfo of subclasses. */
-    def init()(implicit ctx: Context) = loadTypeParams
+    def init()(implicit ctx: Context): List[TypeSymbol] = loadTypeParams
 
     override def completerTypeParams(sym: Symbol)(implicit ctx: Context): List[TypeSymbol] =
       loadTypeParams
   }
 
-  def rootClassUnpickler(start: Coord, cls: Symbol, module: Symbol, infoRef: Int) =
+  def rootClassUnpickler(start: Coord, cls: Symbol, module: Symbol, infoRef: Int): ClassUnpickler =
     (new ClassUnpickler(infoRef) with SymbolLoaders.SecondCompleter {
       override def startCoord(denot: SymDenotation): Coord = start
     }) withDecls symScope(cls) withSourceModule (_ => module)
@@ -759,7 +758,7 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
         TempClassInfoType(until(end, () => readTypeRef()), symScope(clazz), clazz)
       case METHODtpe | IMPLICITMETHODtpe =>
         val restpe = readTypeRef()
-        val params = until(end, () => readSymbolRef()).asInstanceOf[List[TermSymbol]]
+        val params = until(end, () => readSymbolRef()).asInstanceOf[List[Symbol]]
         def isImplicit =
           tag == IMPLICITMETHODtpe ||
           params.nonEmpty && (params.head is Implicit)
@@ -1227,10 +1226,10 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
     }
   }
 
-  def noSuchTreeTag(tag: Int, end: Int)(implicit ctx: Context) =
+  def noSuchTreeTag(tag: Int, end: Int)(implicit ctx: Context): Nothing =
     errorBadSignature("unknown tree type (" + tag + ")")
 
-  def unimplementedTree(what: String)(implicit ctx: Context) =
+  def unimplementedTree(what: String)(implicit ctx: Context): Nothing =
     errorBadSignature(s"cannot read $what trees from Scala 2.x signatures")
 
   def readModifiers(isType: Boolean)(implicit ctx: Context): Modifiers = {
diff --git a/compiler/src/dotty/tools/dotc/decompiler/DecompilationPrinter.scala b/compiler/src/dotty/tools/dotc/decompiler/DecompilationPrinter.scala
index 14905bdc9d88..6bed8e30c2df 100644
--- a/compiler/src/dotty/tools/dotc/decompiler/DecompilationPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/decompiler/DecompilationPrinter.scala
@@ -6,9 +6,8 @@ import java.io.{OutputStream, PrintStream}
 import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.tasty.TastyPrinter
-import dotty.tools.dotc.printing.DecompilerPrinter
 import dotty.tools.dotc.tastyreflect.TastyImpl
-import dotty.tools.io.{File, Path}
+import dotty.tools.io.File
 
 /** Phase that prints the trees in all loaded compilation units.
  *
diff --git a/compiler/src/dotty/tools/dotc/decompiler/Main.scala b/compiler/src/dotty/tools/dotc/decompiler/Main.scala
index 61e7e8654e54..dd7cd8d00b15 100644
--- a/compiler/src/dotty/tools/dotc/decompiler/Main.scala
+++ b/compiler/src/dotty/tools/dotc/decompiler/Main.scala
@@ -1,6 +1,6 @@
 package dotty.tools.dotc.decompiler
 
-import java.nio.file.{Files, Paths}
+import java.nio.file.Files
 
 import dotty.tools.dotc
 import dotty.tools.dotc.core.Contexts._
diff --git a/compiler/src/dotty/tools/dotc/fromtasty/ReadTastyTreesFromClasses.scala b/compiler/src/dotty/tools/dotc/fromtasty/ReadTastyTreesFromClasses.scala
index 01197e8c1698..b102555f35f1 100644
--- a/compiler/src/dotty/tools/dotc/fromtasty/ReadTastyTreesFromClasses.scala
+++ b/compiler/src/dotty/tools/dotc/fromtasty/ReadTastyTreesFromClasses.scala
@@ -6,19 +6,15 @@ import core._
 import Decorators._
 import Contexts.Context
 import Symbols.{Symbol, ClassSymbol}
-import SymDenotations.{SymDenotation, ClassDenotation, LazyType}
+import SymDenotations.ClassDenotation
 import typer.FrontEnd
-import Names.TypeName
 import NameOps._
-import Types.Type
-import ast.tpd
 import ast.Trees.Tree
-import util.SourceFile
 import CompilationUnit.mkCompilationUnit
 
 class ReadTastyTreesFromClasses extends FrontEnd {
 
-  override def isTyper = false
+  override def isTyper: Boolean = false
 
   override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] =
     units.flatMap(readTASTY(_)(ctx.addMode(Mode.ReadPositions)))
diff --git a/compiler/src/dotty/tools/dotc/fromtasty/TASTYCompilationUnit.scala b/compiler/src/dotty/tools/dotc/fromtasty/TASTYCompilationUnit.scala
index 1e7360a8662c..77021efa3050 100644
--- a/compiler/src/dotty/tools/dotc/fromtasty/TASTYCompilationUnit.scala
+++ b/compiler/src/dotty/tools/dotc/fromtasty/TASTYCompilationUnit.scala
@@ -4,5 +4,5 @@ import dotty.tools.dotc.CompilationUnit
 import dotty.tools.dotc.util.NoSource
 
 class TASTYCompilationUnit(val className: String) extends CompilationUnit(NoSource) {
-  override def toString = s"class file $className"
+  override def toString: String = s"class file $className"
 }
diff --git a/compiler/src/dotty/tools/dotc/fromtasty/TASTYRun.scala b/compiler/src/dotty/tools/dotc/fromtasty/TASTYRun.scala
index 08562b067e45..09d4d03c4e5c 100644
--- a/compiler/src/dotty/tools/dotc/fromtasty/TASTYRun.scala
+++ b/compiler/src/dotty/tools/dotc/fromtasty/TASTYRun.scala
@@ -5,7 +5,7 @@ package fromtasty
 import core.Contexts._
 
 class TASTYRun(comp: Compiler, ictx: Context) extends Run(comp, ictx) {
-  override def compile(classNames: List[String]) = {
+  override def compile(classNames: List[String]): Unit = {
     val units = classNames.map(new TASTYCompilationUnit(_))
     compileUnits(units)
   }
diff --git a/compiler/src/dotty/tools/dotc/interactive/Interactive.scala b/compiler/src/dotty/tools/dotc/interactive/Interactive.scala
index 9c091ad5e2b2..16335f3e5f09 100644
--- a/compiler/src/dotty/tools/dotc/interactive/Interactive.scala
+++ b/compiler/src/dotty/tools/dotc/interactive/Interactive.scala
@@ -7,7 +7,7 @@ import scala.collection._
 
 import ast.{NavigateAST, Trees, tpd, untpd}
 import core._, core.Decorators.{sourcePos => _, _}
-import Contexts._, Flags._, Names._, NameOps._, Symbols._, SymDenotations._, Trees._, Types._
+import Contexts._, Flags._, Names._, NameOps._, Symbols._, Trees._, Types._
 import util.Positions._, util.SourcePosition
 import core.Denotations.SingleDenotation
 import NameKinds.SimpleNameKind
@@ -23,15 +23,15 @@ object Interactive {
 
   object Include { // should be an enum, really.
     type Set = Int
-    val overridden = 1 // include trees whose symbol is overridden by `sym`
-    val overriding = 2 // include trees whose symbol overrides `sym` (but for performance only in same source file)
-    val references = 4 // include references
-    val definitions = 8 // include definitions
-    val linkedClass = 16 // include `symbol.linkedClass`
+    val overridden: Int = 1 // include trees whose symbol is overridden by `sym`
+    val overriding: Int = 2 // include trees whose symbol overrides `sym` (but for performance only in same source file)
+    val references: Int = 4 // include references
+    val definitions: Int = 8 // include definitions
+    val linkedClass: Int = 16 // include `symbol.linkedClass`
   }
 
   /** Does this tree define a symbol ? */
-  def isDefinition(tree: Tree) =
+  def isDefinition(tree: Tree): Boolean =
     tree.isInstanceOf[DefTree with NameTree]
 
   /** The type of the closest enclosing tree with a type containing position `pos`. */
@@ -367,7 +367,6 @@ object Interactive {
     case Nil | _ :: Nil =>
       ctx.run.runContext.fresh.setCompilationUnit(ctx.compilationUnit)
     case nested :: encl :: rest =>
-      import typer.Typer._
       val outer = contextOfPath(encl :: rest)
       try encl match {
         case tree @ PackageDef(pkg, stats) =>
diff --git a/compiler/src/dotty/tools/dotc/interactive/InteractiveCompiler.scala b/compiler/src/dotty/tools/dotc/interactive/InteractiveCompiler.scala
index 661d0bc686aa..2fdc2fc657b5 100644
--- a/compiler/src/dotty/tools/dotc/interactive/InteractiveCompiler.scala
+++ b/compiler/src/dotty/tools/dotc/interactive/InteractiveCompiler.scala
@@ -5,7 +5,6 @@ package interactive
 import core._
 import Phases._
 import typer._
-import Contexts._
 
 class InteractiveCompiler extends Compiler {
   // TODO: Figure out what phases should be run in IDEs
diff --git a/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala b/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala
index e7f432107829..281bbe04fbb1 100644
--- a/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala
+++ b/compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala
@@ -6,19 +6,16 @@ import java.net.URI
 import java.io._
 import java.nio.file._
 import java.nio.file.attribute.BasicFileAttributes
-import java.util.stream._
 import java.util.zip._
-import java.util.function._
 
 import scala.collection._
-import JavaConverters._
 import scala.io.Codec
 
 import dotty.tools.io.{ ClassPath, ClassRepresentation, PlainFile, VirtualFile }
 
 import ast.{Trees, tpd}
 import core._, core.Decorators._
-import Contexts._, Flags._, Names._, NameOps._, Symbols._, SymDenotations._, Trees._, Types._
+import Contexts._, Names._, NameOps._, Symbols._, SymDenotations._, Trees._, Types._
 import classpath._
 import reporting._, reporting.diagnostic.MessageContainer
 import util._
@@ -26,9 +23,8 @@ import util._
 /** A Driver subclass designed to be used from IDEs */
 class InteractiveDriver(val settings: List[String]) extends Driver {
   import tpd._
-  import InteractiveDriver._
 
-  override def sourcesRequired = false
+  override def sourcesRequired: Boolean = false
 
   private val myInitCtx: Context = {
     val rootCtx = initCtx.fresh.addMode(Mode.ReadPositions).addMode(Mode.Interactive).addMode(Mode.ReadComments)
@@ -269,6 +265,6 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
 }
 
 object InteractiveDriver {
-  def toUri(source: SourceFile) = Paths.get(source.file.path).toUri
+  def toUri(source: SourceFile): URI = Paths.get(source.file.path).toUri
 }
 
diff --git a/compiler/src/dotty/tools/dotc/interactive/SourceTree.scala b/compiler/src/dotty/tools/dotc/interactive/SourceTree.scala
index 37c033aa68e9..2e0978085504 100644
--- a/compiler/src/dotty/tools/dotc/interactive/SourceTree.scala
+++ b/compiler/src/dotty/tools/dotc/interactive/SourceTree.scala
@@ -5,7 +5,7 @@ package interactive
 import scala.io.Codec
 
 import ast.tpd
-import core._, core.Decorators.{sourcePos => _, _}
+import core._, core.Decorators.{sourcePos => _}
 import Contexts._, NameOps._, Symbols._, StdNames._
 import util._, util.Positions._
 
diff --git a/compiler/src/dotty/tools/dotc/parsing/CharArrayReader.scala b/compiler/src/dotty/tools/dotc/parsing/CharArrayReader.scala
index 431ec041772c..3eef265e5a2a 100644
--- a/compiler/src/dotty/tools/dotc/parsing/CharArrayReader.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/CharArrayReader.scala
@@ -7,7 +7,7 @@ import util.Chars._
 abstract class CharArrayReader { self =>
 
   val buf: Array[Char]
-  protected def startFrom = 0
+  protected def startFrom: Int = 0
 
   /** Switch whether unicode should be decoded */
   protected def decodeUni: Boolean = true
@@ -33,7 +33,7 @@ abstract class CharArrayReader { self =>
   private[this] var lastUnicodeOffset = -1
 
   /** Is last character a unicode escape \\uxxxx? */
-  def isUnicodeEscape = charOffset == lastUnicodeOffset
+  def isUnicodeEscape: Boolean = charOffset == lastUnicodeOffset
 
   /** Advance one character; reducing CR;LF pairs to just LF */
   final def nextChar(): Unit = {
@@ -50,7 +50,7 @@ abstract class CharArrayReader { self =>
     }
   }
 
-  def getc() = { nextChar() ; ch }
+  def getc(): Char = { nextChar() ; ch }
 
   /** Advance one character, leaving CR;LF pairs intact.
    *  This is for use in multi-line strings, so there are no
@@ -117,16 +117,16 @@ abstract class CharArrayReader { self =>
     }
   }
 
-  def isAtEnd = charOffset >= buf.length
+  def isAtEnd: Boolean = charOffset >= buf.length
 
   /** A new reader that takes off at the current character position */
-  def lookaheadReader() = new CharArrayLookaheadReader
+  def lookaheadReader(): CharArrayLookaheadReader = new CharArrayLookaheadReader
 
   class CharArrayLookaheadReader extends CharArrayReader {
-    val buf = self.buf
+    val buf: Array[Char] = self.buf
     charOffset = self.charOffset
     ch = self.ch
-    override def decodeUni = self.decodeUni
-    def error(msg: String, offset: Int) = self.error(msg, offset)
+    override def decodeUni: Boolean = self.decodeUni
+    def error(msg: String, offset: Int): Unit = self.error(msg, offset)
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
index f22afb941c73..e16d27ce06af 100644
--- a/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/JavaParsers.scala
@@ -6,7 +6,6 @@ import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Flags.FlagSet
 
-import scala.language.implicitConversions
 
 import JavaTokens._
 import JavaScanners._
@@ -15,7 +14,6 @@ import Parsers._
 import core._
 import Contexts._
 import Names._
-import NameOps._
 import Types._
 import Symbols._
 import ast.Trees._
@@ -24,7 +22,6 @@ import StdNames._
 import dotty.tools.dotc.reporting.diagnostic.messages.IdentifierExpected
 import dotty.tools.dotc.util.SourceFile
 import util.Positions._
-import annotation.switch
 import scala.collection.mutable.ListBuffer
 
 object JavaParsers {
@@ -33,7 +30,7 @@ object JavaParsers {
 
   class JavaParser(source: SourceFile)(implicit ctx: Context) extends ParserCommon(source) {
 
-    val definitions = ctx.definitions
+    val definitions: Definitions = ctx.definitions
     import definitions._
 
     val in: JavaScanner = new JavaScanner(source)
@@ -90,11 +87,11 @@ object JavaParsers {
         skip()
     }
 
-    def errorTypeTree = TypeTree().withType(UnspecifiedErrorType) withPos Position(in.offset)
+    def errorTypeTree: TypeTree = TypeTree().withType(UnspecifiedErrorType) withPos Position(in.offset)
 
     // --------- tree building -----------------------------
 
-    def scalaAnnotationDot(name: Name) = Select(scalaDot(nme.annotation), name)
+    def scalaAnnotationDot(name: Name): Select = Select(scalaDot(nme.annotation), name)
 
     def javaDot(name: Name): Tree =
       Select(rootDot(nme.java), name)
@@ -104,13 +101,13 @@ object JavaParsers {
 
     def javaLangObject(): Tree = javaLangDot(tpnme.Object)
 
-    def arrayOf(tpt: Tree) =
+    def arrayOf(tpt: Tree): AppliedTypeTree =
       AppliedTypeTree(Ident(nme.Array.toTypeName), List(tpt))
 
-    def unimplementedExpr(implicit ctx: Context) =
+    def unimplementedExpr(implicit ctx: Context): Select =
       Select(Select(rootDot(nme.scala_), nme.Predef), nme.???)
 
-    def makeTemplate(parents: List[Tree], stats: List[Tree], tparams: List[TypeDef], needsDummyConstr: Boolean) = {
+    def makeTemplate(parents: List[Tree], stats: List[Tree], tparams: List[TypeDef], needsDummyConstr: Boolean): Template = {
       def pullOutFirstConstr(stats: List[Tree]): (Tree, List[Tree]) = stats match {
         case (meth: DefDef) :: rest if meth.name == nme.CONSTRUCTOR => (meth, rest)
         case first :: rest =>
@@ -136,7 +133,7 @@ object JavaParsers {
     def makeParam(name: TermName, tpt: Tree, defaultValue: Tree = EmptyTree): ValDef =
       ValDef(name, tpt, defaultValue).withMods(Modifiers(Flags.JavaDefined | Flags.Param))
 
-    def makeConstructor(formals: List[Tree], tparams: List[TypeDef], flags: FlagSet = Flags.JavaDefined) = {
+    def makeConstructor(formals: List[Tree], tparams: List[TypeDef], flags: FlagSet = Flags.JavaDefined): DefDef = {
       val vparams = formals.zipWithIndex.map { case (p, i) => makeSyntheticParam(i + 1, p) }
       DefDef(nme.CONSTRUCTOR, tparams, List(vparams), TypeTree(), EmptyTree).withMods(Modifiers(flags))
     }
@@ -470,7 +467,7 @@ object JavaParsers {
       unimplementedExpr
     }
 
-    def definesInterface(token: Int) = token == INTERFACE || token == AT
+    def definesInterface(token: Int): Boolean = token == INTERFACE || token == AT
 
     def termDecl(start: Offset, mods: Modifiers, parentToken: Int, parentTParams: List[TypeDef]): List[Tree] = {
       val inInterface = definesInterface(parentToken)
@@ -673,7 +670,7 @@ object JavaParsers {
       }
     }
 
-    def interfacesOpt() =
+    def interfacesOpt(): List[Tree] =
       if (in.token == IMPLEMENTS) {
         in.nextToken()
         repsep(() => typ(), COMMA)
@@ -761,7 +758,7 @@ object JavaParsers {
       val idefs = members.toList ::: (sdefs flatMap forwarders)
       (sdefs, idefs)
     }
-    def annotationParents = List(
+    def annotationParents: List[Select] = List(
       scalaAnnotationDot(tpnme.Annotation),
       Select(javaLangDot(nme.annotation), tpnme.Annotation),
       scalaAnnotationDot(tpnme.ClassfileAnnotation)
@@ -847,7 +844,7 @@ object JavaParsers {
       addCompanionObject(consts ::: statics ::: predefs, enumclazz)
     }
 
-    def enumConst(enumType: Tree) = {
+    def enumConst(enumType: Tree): ValDef = {
       annotations()
       atPos(in.offset) {
         val name = ident()
@@ -915,7 +912,7 @@ object JavaParsers {
    *  classname alone.
    */
   class OutlineJavaParser(source: SourceFile)(implicit ctx: Context) extends JavaParser(source) with OutlineParserCommon {
-    override def skipBracesHook() = None
+    override def skipBracesHook(): Option[Tree] = None
     override def typeBody(leadingToken: Int, parentName: Name, parentTParams: List[TypeDef]): (List[Tree], List[Tree]) = {
       skipBraces()
       (List(EmptyValDef), List(EmptyTree))
diff --git a/compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala b/compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala
index 09ce8a9a38bc..10435003838d 100644
--- a/compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala
@@ -2,7 +2,7 @@ package dotty.tools
 package dotc
 package parsing
 
-import core.Names._, core.Contexts._, core.Decorators._, util.Positions._
+import core.Contexts._
 import Scanners._
 import util.SourceFile
 import JavaTokens._
@@ -388,7 +388,7 @@ object JavaScanners {
 
     /** read next character in character or string literal:
       */
-    protected def getlitch() =
+    protected def getlitch(): Unit =
       if (ch == '\\') {
         nextChar()
         if ('0' <= ch && ch <= '7') {
@@ -506,7 +506,7 @@ object JavaScanners {
 
     // Errors -----------------------------------------------------------------
 
-    override def toString() = token match {
+    override def toString(): String = token match {
       case IDENTIFIER =>
         "id(" + name + ")"
       case CHARLIT =>
@@ -534,5 +534,5 @@ object JavaScanners {
     nextToken()
   }
 
-  val (lastKeywordStart, kwArray) = buildKeywordArray(keywords)
+  private val (lastKeywordStart, kwArray) = buildKeywordArray(keywords)
 }
diff --git a/compiler/src/dotty/tools/dotc/parsing/JavaTokens.scala b/compiler/src/dotty/tools/dotc/parsing/JavaTokens.scala
index 5412481f07bf..79dd549cdf0d 100644
--- a/compiler/src/dotty/tools/dotc/parsing/JavaTokens.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/JavaTokens.scala
@@ -6,13 +6,13 @@ import collection.immutable.BitSet
 
 object JavaTokens extends TokensCommon {
   final val minToken = EMPTY
-  final def maxToken = DOUBLE
+  final def maxToken: Int = DOUBLE
 
-  final val javaOnlyKeywords = tokenRange(INSTANCEOF, ASSERT)
-  final val sharedKeywords = BitSet( IF, FOR, ELSE, THIS, NULL, NEW, SUPER, ABSTRACT, FINAL, PRIVATE, PROTECTED,
+  final val javaOnlyKeywords: TokenSet = tokenRange(INSTANCEOF, ASSERT)
+  final val sharedKeywords: BitSet = BitSet( IF, FOR, ELSE, THIS, NULL, NEW, SUPER, ABSTRACT, FINAL, PRIVATE, PROTECTED,
     OVERRIDE, EXTENDS, TRUE, FALSE, CLASS, IMPORT, PACKAGE, DO, THROW, TRY, CATCH, FINALLY, WHILE, RETURN )
-  final val primTypes = tokenRange(VOID, DOUBLE)
-  final val keywords = sharedKeywords | javaOnlyKeywords | primTypes
+  final val primTypes: TokenSet = tokenRange(VOID, DOUBLE)
+  final val keywords: BitSet = sharedKeywords | javaOnlyKeywords | primTypes
 
   /** keywords */
   final val INSTANCEOF = 101;       enter(INSTANCEOF, "instanceof")
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 0b67a9e0668d..2a39323c5ee5 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -14,16 +14,13 @@ import Flags._
 import Contexts._
 import Names._
 import NameKinds.WildcardParamName
-import ast.{Positioned, Trees, untpd}
+import ast.{Positioned, Trees}
 import ast.Trees._
-import Decorators._
 import StdNames._
 import util.Positions._
 import Constants._
 import ScriptParsers._
-import Comments._
 import scala.annotation.{tailrec, switch}
-import util.DotClass
 import rewrites.Rewrites.patch
 
 object Parsers {
@@ -37,17 +34,17 @@ object Parsers {
   class ParensCounters {
     private[this] var parCounts = new Array[Int](lastParen - firstParen)
 
-    def count(tok: Token) = parCounts(tok - firstParen)
-    def change(tok: Token, delta: Int) = parCounts(tok - firstParen) += delta
+    def count(tok: Token): Int = parCounts(tok - firstParen)
+    def change(tok: Token, delta: Int): Unit = parCounts(tok - firstParen) += delta
     def nonePositive: Boolean = parCounts forall (_ <= 0)
   }
 
   @sharable object Location extends Enumeration {
-    val InParens, InBlock, InPattern, ElseWhere = Value
+    val InParens, InBlock, InPattern, ElseWhere: Value = Value
   }
 
   @sharable object ParamOwner extends Enumeration {
-    val Class, Type, TypeParam, Def = Value
+    val Class, Type, TypeParam, Def: Value = Value
   }
 
   private implicit class AddDeco(val buf: ListBuffer[Tree]) extends AnyVal {
@@ -60,7 +57,7 @@ object Parsers {
   /** The parse starting point depends on whether the source file is self-contained:
    *  if not, the AST will be supplemented.
    */
-  def parser(source: SourceFile)(implicit ctx: Context) =
+  def parser(source: SourceFile)(implicit ctx: Context): Parser =
     if (source.isSelfContained) new ScriptParser(source)
     else new Parser(source)
 
@@ -151,7 +148,7 @@ object Parsers {
 
     val in: Scanner = new Scanner(source)
 
-    val openParens = new ParensCounters
+    val openParens: ParensCounters = new ParensCounters
 
     /** This is the general parse entry point.
      *  Overridden by ScriptParser
@@ -164,23 +161,23 @@ object Parsers {
 
 /* -------------- TOKEN CLASSES ------------------------------------------- */
 
-    def isIdent = in.token == IDENTIFIER || in.token == BACKQUOTED_IDENT
-    def isIdent(name: Name) = in.token == IDENTIFIER && in.name == name
-    def isSimpleLiteral = simpleLiteralTokens contains in.token
-    def isLiteral = literalTokens contains in.token
-    def isNumericLit = numericLitTokens contains in.token
-    def isModifier = modifierTokens.contains(in.token) || isIdent(nme.INLINEkw)
-    def isBindingIntro = canStartBindingTokens contains in.token
-    def isTemplateIntro = templateIntroTokens contains in.token
-    def isDclIntro = dclIntroTokens contains in.token
-    def isStatSeqEnd = in.token == RBRACE || in.token == EOF
-    def mustStartStat = mustStartStatTokens contains in.token
-
-    def isExprIntro =
+    def isIdent: Boolean = in.token == IDENTIFIER || in.token == BACKQUOTED_IDENT
+    def isIdent(name: Name): Boolean = in.token == IDENTIFIER && in.name == name
+    def isSimpleLiteral: Boolean = simpleLiteralTokens contains in.token
+    def isLiteral: Boolean = literalTokens contains in.token
+    def isNumericLit: Boolean = numericLitTokens contains in.token
+    def isModifier: Boolean = modifierTokens.contains(in.token) || isIdent(nme.INLINEkw)
+    def isBindingIntro: Boolean = canStartBindingTokens contains in.token
+    def isTemplateIntro: Boolean = templateIntroTokens contains in.token
+    def isDclIntro: Boolean = dclIntroTokens contains in.token
+    def isStatSeqEnd: Boolean = in.token == RBRACE || in.token == EOF
+    def mustStartStat: Boolean = mustStartStatTokens contains in.token
+
+    def isExprIntro: Boolean =
       (canStartExpressionTokens `contains` in.token) &&
         (!isIdent(nme.INLINEkw) || lookaheadIn(canStartExpressionTokens))
 
-    def isDefIntro(allowedMods: BitSet) =
+    def isDefIntro(allowedMods: BitSet): Boolean =
       in.token == AT ||
       (defIntroTokens `contains` in.token) ||
       (allowedMods `contains` in.token) ||
@@ -196,7 +193,7 @@ object Parsers {
      */
     private[this] var lastStatOffset = -1
 
-    def setLastStatOffset() =
+    def setLastStatOffset(): Unit =
       if (mustStartStat && in.isAfterLineEnd())
         lastStatOffset = in.offset
 
@@ -256,23 +253,23 @@ object Parsers {
       }
     }
 
-    def warning(msg: => Message, sourcePos: SourcePosition) =
+    def warning(msg: => Message, sourcePos: SourcePosition): Unit =
       ctx.warning(msg, sourcePos)
 
-    def warning(msg: => Message, offset: Int = in.offset) =
+    def warning(msg: => Message, offset: Int = in.offset): Unit =
       ctx.warning(msg, source atPos Position(offset))
 
-    def deprecationWarning(msg: => Message, offset: Int = in.offset) =
+    def deprecationWarning(msg: => Message, offset: Int = in.offset): Unit =
       ctx.deprecationWarning(msg, source atPos Position(offset))
 
     /** Issue an error at current offset that input is incomplete */
-    def incompleteInputError(msg: => Message) =
+    def incompleteInputError(msg: => Message): Unit =
       ctx.incompleteInputError(msg, source atPos Position(in.offset))
 
     /** If at end of file, issue an incompleteInputError.
      *  Otherwise issue a syntax error and skip to next safe point.
      */
-    def syntaxErrorOrIncomplete(msg: => Message) =
+    def syntaxErrorOrIncomplete(msg: => Message): Unit =
       if (in.token == EOF) incompleteInputError(msg)
       else {
         syntaxError(msg)
@@ -302,7 +299,7 @@ object Parsers {
       case _                  => accept(SEMI)
     }
 
-    def acceptStatSepUnlessAtEnd(altEnd: Token = EOF) =
+    def acceptStatSepUnlessAtEnd(altEnd: Token = EOF): Unit =
       if (!isStatSeqEnd)
         in.token match {
           case EOF =>
@@ -314,7 +311,7 @@ object Parsers {
             accept(SEMI)
         }
 
-    def errorTermTree    = atPos(in.offset) { Literal(Constant(null)) }
+    def errorTermTree: Literal = atPos(in.offset) { Literal(Constant(null)) }
 
     private[this] var inFunReturnType = false
     private def fromWithinReturnType[T](body: => T): T = {
@@ -344,7 +341,7 @@ object Parsers {
       finally inEnum = saved
     }
 
-    def migrationWarningOrError(msg: String, offset: Int = in.offset) =
+    def migrationWarningOrError(msg: String, offset: Int = in.offset): Unit =
       if (in.isScala2Mode)
         ctx.migrationWarning(msg, source atPos Position(offset))
       else
@@ -416,7 +413,7 @@ object Parsers {
 /* -------------- XML ---------------------------------------------------- */
 
     /** the markup parser */
-    lazy val xmlp = new MarkupParser(this, true)
+    lazy val xmlp: xml.MarkupParsers.MarkupParser = new MarkupParser(this, true)
 
     object symbXMLBuilder extends xml.SymbolicXMLBuilder(this, true) // DEBUG choices
 
@@ -588,7 +585,7 @@ object Parsers {
      *  @param finish   An alternative parse in case the token following a `.' is not an identifier.
      *                  If the alternative does not apply, its tree argument is returned unchanged.
      */
-     def dotSelectors(t: Tree, finish: Tree => Tree = id) =
+     def dotSelectors(t: Tree, finish: Tree => Tree = id): Tree =
       if (in.token == DOT) { in.nextToken(); selectors(t, finish) }
       else t
 
@@ -931,7 +928,7 @@ object Parsers {
 
     /** NamedTypeArg      ::=  id `=' Type
      */
-    val namedTypeArg = () => {
+    val namedTypeArg: () => NamedArg = () => {
       val name = ident()
       accept(EQUALS)
       NamedArg(name.toTypeName, typ())
@@ -940,7 +937,7 @@ object Parsers {
     /**   ArgTypes          ::=  Type {`,' Type}
      *                        |  NamedTypeArg {`,' NamedTypeArg}
      */
-    def argTypes(namedOK: Boolean, wildOK: Boolean) = {
+    def argTypes(namedOK: Boolean, wildOK: Boolean): List[Tree] = {
       def otherArgs(first: Tree, arg: () => Tree): List[Tree] = {
         val rest =
           if (in.token == COMMA) {
@@ -964,7 +961,7 @@ object Parsers {
 
     /** FunArgType ::=  Type | `=>' Type
      */
-    val funArgType = () =>
+    val funArgType: () => Tree = () =>
       if (in.token == ARROW) atPos(in.skipToken()) { ByNameTypeTree(typ()) }
       else typ()
 
@@ -1125,7 +1122,7 @@ object Parsers {
      *                      | `:' Annotation {Annotation}
      *                      | `:' `_' `*'
      */
-    val exprInParens = () => expr(Location.InParens)
+    val exprInParens: () => Tree = () => expr(Location.InParens)
 
     def expr(): Tree = expr(Location.ElseWhere)
 
@@ -1216,7 +1213,7 @@ object Parsers {
         expr1Rest(postfixExpr(), location)
     }
 
-    def expr1Rest(t: Tree, location: Location.Value) = in.token match {
+    def expr1Rest(t: Tree, location: Location.Value): Tree = in.token match {
       case EQUALS =>
          t match {
            case Ident(_) | Select(_, _) | Apply(_, _) =>
@@ -1232,7 +1229,7 @@ object Parsers {
         t
     }
 
-    def ascription(t: Tree, location: Location.Value) = atPos(startOffset(t)) {
+    def ascription(t: Tree, location: Location.Value): Tree = atPos(startOffset(t)) {
       in.skipToken()
       in.token match {
         case USCORE =>
@@ -1274,14 +1271,14 @@ object Parsers {
     /**    `match' { CaseClauses }
      *     `match' { ImplicitCaseClauses }
      */
-    def matchExpr(t: Tree, start: Offset) =
+    def matchExpr(t: Tree, start: Offset): Match =
       atPos(start, in.skipToken()) {
         inBraces(Match(t, caseClauses(caseClause)))
       }
 
     /**    `match' { TypeCaseClauses }
      */
-    def matchType(bound: Tree, t: Tree) =
+    def matchType(bound: Tree, t: Tree): MatchTypeTree =
       atPos((if (bound.isEmpty) t else bound).pos.start, accept(MATCH)) {
         inBraces(MatchTypeTree(bound, t, caseClauses(typeCaseClause)))
       }
@@ -1348,7 +1345,7 @@ object Parsers {
 
     /** PrefixExpr   ::= [`-' | `+' | `~' | `!'] SimpleExpr
     */
-    val prefixExpr = () =>
+    val prefixExpr: () => Tree = () =>
       if (isIdent && nme.raw.isUnary(in.name)) {
         val start = in.offset
         val op = termIdent()
@@ -1457,7 +1454,7 @@ object Parsers {
     def argumentExprs(): List[Tree] =
       if (in.token == LBRACE) blockExpr() :: Nil else parArgumentExprs()
 
-    val argumentExpr = () => exprInParens() match {
+    val argumentExpr: () => Tree = () => exprInParens() match {
       case arg @ Assign(Ident(id), rhs) => cpy.NamedArg(arg)(id, rhs)
       case arg => arg
     }
@@ -1550,7 +1547,7 @@ object Parsers {
      */
     def generator(): Tree = generatorRest(pattern1())
 
-    def generatorRest(pat: Tree) =
+    def generatorRest(pat: Tree): GenFrom =
       atPos(startOffset(pat), accept(LARROW)) { GenFrom(pat, expr()) }
 
     /** ForExpr  ::= `for' (`(' Enumerators `)' | `{' Enumerators `}')
@@ -1606,14 +1603,14 @@ object Parsers {
    /** CaseClause         ::= ‘case’ Pattern [Guard] `=>' Block
     *  ImplicitCaseClause ::= ‘case’ PatVar [Ascription] [Guard] `=>' Block
     */
-    val caseClause = () => atPos(in.offset) {
+    val caseClause: () => CaseDef = () => atPos(in.offset) {
       accept(CASE)
       CaseDef(pattern(), guard(), atPos(accept(ARROW)) { block() })
     }
 
     /** TypeCaseClause     ::= ‘case’ InfixType ‘=>’ Type [nl]
      */
-    val typeCaseClause = () => atPos(in.offset) {
+    val typeCaseClause: () => CaseDef = () => atPos(in.offset) {
       accept(CASE)
       CaseDef(infixType(), EmptyTree, atPos(accept(ARROW)) {
         val t = typ()
@@ -1626,7 +1623,7 @@ object Parsers {
 
     /**  Pattern           ::=  Pattern1 { `|' Pattern1 }
      */
-    val pattern = () => {
+    val pattern: () => Tree = () => {
       val pat = pattern1()
       if (isIdent(nme.raw.BAR))
         atPos(startOffset(pat)) { Alternative(pat :: patternAlts()) }
@@ -1648,7 +1645,7 @@ object Parsers {
 
     /**  Pattern2    ::=  [id `@'] InfixPattern
      */
-    val pattern2 = () => infixPattern() match {
+    val pattern2: () => Tree = () => infixPattern() match {
       case p @ Ident(name) if in.token == AT =>
         val offset = in.skipToken()
 
@@ -1683,7 +1680,7 @@ object Parsers {
      *  PatVar           ::= id
      *                    |  `_'
      */
-    val simplePattern = () => in.token match {
+    val simplePattern: () => Tree = () => in.token match {
       case IDENTIFIER | BACKQUOTED_IDENT | THIS =>
         path(thisOK = true) match {
           case id @ Ident(nme.raw.MINUS) if isNumericLit => literal(startOffset(id))
@@ -1722,7 +1719,7 @@ object Parsers {
 
     /** Patterns          ::=  Pattern [`,' Pattern]
      */
-    def patterns() = commaSeparated(pattern)
+    def patterns(): List[Tree] = commaSeparated(pattern)
 
     def patternsOpt(): List[Tree] =
       if (in.token == RPAREN) Nil else patterns()
@@ -1833,10 +1830,10 @@ object Parsers {
 
     /** FunArgMods ::= { `implicit` | `erased` }
      */
-    def funArgMods = BitSet(IMPLICIT, ERASED)
+    def funArgMods: BitSet = BitSet(IMPLICIT, ERASED)
 
     /** Wrap annotation or constructor in New(...).<init> */
-    def wrapNew(tpt: Tree) = Select(New(tpt), nme.CONSTRUCTOR)
+    def wrapNew(tpt: Tree): Select = Select(New(tpt), nme.CONSTRUCTOR)
 
     /** Adjust start of annotation or constructor to position of preceding @ or new */
     def adjustStart(start: Offset)(tree: Tree): Tree = {
@@ -1852,7 +1849,7 @@ object Parsers {
 
     /** Annotation        ::=  `@' SimpleType {ParArgumentExprs}
      */
-    def annot() =
+    def annot(): Tree =
       adjustStart(accept(AT)) {
         ensureApplied(parArgumentExprss(wrapNew(simpleType())))
       }
@@ -2041,7 +2038,7 @@ object Parsers {
 
     /**  ImportExpr ::= StableId `.' (id | `_' | ImportSelectors)
      */
-    val importExpr = () => path(thisOK = false, handleImport) match {
+    val importExpr: () => Import = () => path(thisOK = false, handleImport) match {
       case imp: Import =>
         imp
       case sel @ Select(qual, name) =>
@@ -2052,7 +2049,7 @@ object Parsers {
         Import(t, Ident(nme.WILDCARD) :: Nil)
     }
 
-    val handleImport = { tree: Tree =>
+    val handleImport: Tree => Tree = { tree: Tree =>
       if (in.token == USCORE) Import(tree, importSelector() :: Nil)
       else if (in.token == LBRACE) Import(tree, inBraces(importSelectors()))
       else tree
@@ -2094,7 +2091,7 @@ object Parsers {
       else from
     }
 
-    def posMods(start: Int, mods: Modifiers) = {
+    def posMods(start: Int, mods: Modifiers): Modifiers = {
       val mods1 = atPos(start)(mods)
       in.nextToken()
       mods1
@@ -2155,7 +2152,7 @@ object Parsers {
       }
     }
 
-    private def checkVarArgsRules(vparamss: List[List[untpd.ValDef]]): List[untpd.ValDef] = {
+    private def checkVarArgsRules(vparamss: List[List[ValDef]]): List[ValDef] = {
       def isVarArgs(tpt: Trees.Tree[Untyped]): Boolean = tpt match {
         case PostfixOp(_, op) if op.name == tpnme.raw.STAR => true
         case _ => false
@@ -2395,7 +2392,7 @@ object Parsers {
 
     /** ConstrApp         ::=  SimpleType {ParArgumentExprs}
      */
-    val constrApp = () => {
+    val constrApp: () => Tree = () => {
       // Using Ident(nme.ERROR) to avoid causing cascade errors on non-user-written code
       val t = checkWildcard(annotType(), fallbackTree = Ident(nme.ERROR))
       if (in.token == LPAREN) parArgumentExprss(wrapNew(t))
@@ -2433,7 +2430,7 @@ object Parsers {
 
     /** TemplateBody ::= [nl] `{' TemplateStatSeq `}'
      */
-    def templateBodyOpt(constr: DefDef, parents: List[Tree], isEnum: Boolean) = {
+    def templateBodyOpt(constr: DefDef, parents: List[Tree], isEnum: Boolean): Template = {
       val (self, stats) =
         if (in.token == LBRACE) withinEnum(isEnum)(templateBody()) else (EmptyValDef, Nil)
       Template(constr, parents, self, stats)
@@ -2686,7 +2683,7 @@ object Parsers {
       EmptyTree
     }
 
-    override def templateBody() = {
+    override def templateBody(): (ValDef, List[Thicket]) = {
       skipBraces()
       (EmptyValDef, List(EmptyTree))
     }
diff --git a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
index 415c6904eb6c..5b54f4f42308 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Scanners.scala
@@ -12,7 +12,6 @@ import Tokens._
 import scala.annotation.{ switch, tailrec }
 import scala.collection.mutable
 import scala.collection.immutable.SortedMap
-import mutable.ListBuffer
 import rewrites.Rewrites.patch
 
 object Scanners {
@@ -45,7 +44,7 @@ object Scanners {
     /** the base of a number */
     var base: Int = 0
 
-    def copyFrom(td: TokenData) = {
+    def copyFrom(td: TokenData): Unit = {
       this.token = td.token
       this.offset = td.offset
       this.lastOffset = td.lastOffset
@@ -56,7 +55,7 @@ object Scanners {
   }
 
   abstract class ScannerCommon(source: SourceFile)(implicit ctx: Context) extends CharArrayReader with TokenData {
-    val buf = source.content
+    val buf: Array[Char] = source.content
     def nextToken(): Unit
 
     // Errors -----------------------------------------------------------------
@@ -66,7 +65,7 @@ object Scanners {
     var errOffset: Offset = NoOffset
 
     /** Generate an error at the given offset */
-    def error(msg: String, off: Offset = offset) = {
+    def error(msg: String, off: Offset = offset): Unit = {
       ctx.error(msg, source atPos Position(off))
       token = ERROR
       errOffset = off
@@ -83,7 +82,7 @@ object Scanners {
 
     /** A character buffer for literals
       */
-    val litBuf = new StringBuilder
+    protected val litBuf: mutable.StringBuilder = new StringBuilder
 
     /** append Unicode character to "litBuf" buffer
       */
@@ -109,7 +108,7 @@ object Scanners {
     def toToken(idx: Int): Token
 
     /** Clear buffer and set string */
-    def setStrVal() =
+    def setStrVal(): Unit =
       strVal = flushBuf(litBuf)
 
     /** Convert current strVal to char value
@@ -173,7 +172,7 @@ object Scanners {
   }
 
   class Scanner(source: SourceFile, override val startFrom: Offset = 0)(implicit ctx: Context) extends ScannerCommon(source)(ctx) {
-    val keepComments = !ctx.settings.YdropComments.value
+    val keepComments: Boolean = !ctx.settings.YdropComments.value
 
     /** All doc comments kept by their end position in a `Map` */
     private[this] var docstringMap: SortedMap[Int, Comment] = SortedMap.empty
@@ -195,7 +194,7 @@ object Scanners {
     def getDocComment(pos: Int): Option[Comment] = docstringMap.get(pos)
 
     /** A buffer for comments */
-    val commentBuf = new StringBuilder
+    private[this] val commentBuf: mutable.StringBuilder = new StringBuilder
 
     private def handleMigration(keyword: Token): Token =
       if (!isScala2Mode) keyword
@@ -237,10 +236,10 @@ object Scanners {
 
 // Scala 2 compatibility
 
-    val isScala2Mode = ctx.settings.language.value.contains(nme.Scala2.toString)
+    val isScala2Mode: Boolean = ctx.settings.language.value.contains(nme.Scala2.toString)
 
     /** Cannot use ctx.featureEnabled because accessing the context would force too much */
-    def testScala2Mode(msg: String, pos: Position = Position(offset)) = {
+    def testScala2Mode(msg: String, pos: Position = Position(offset)): Boolean = {
       if (isScala2Mode) ctx.migrationWarning(msg, source atPos pos)
       isScala2Mode
     }
@@ -297,7 +296,7 @@ object Scanners {
     }
 
     /** A new Scanner that starts at the current token offset */
-    def lookaheadScanner = new Scanner(source, offset)
+    def lookaheadScanner: Scanner = new Scanner(source, offset)
 
     /** Produce next token, filling TokenData fields of Scanner.
      */
@@ -337,7 +336,7 @@ object Scanners {
       // print("[" + this +"]")
     }
 
-    def postProcessToken() = {
+    def postProcessToken(): Unit = {
       // Join CASE + CLASS => CASECLASS, CASE + OBJECT => CASEOBJECT, SEMI + ELSE => ELSE
       def lookahead() = {
         prev copyFrom this
@@ -963,7 +962,7 @@ object Scanners {
       case '[' => QBRACKET
     }
 
-    override def toString =
+    override def toString: String =
       showTokenDetailed(token) + {
         if ((identifierTokens contains token) || (literalTokens contains token)) " " + name
         else ""
@@ -989,7 +988,7 @@ object Scanners {
 // (does not seem to be needed) def flush = { charOffset = offset; nextChar(); this }
 
     /* Resume normal scanning after XML */
-    def resume(lastToken: Token) = {
+    def resume(lastToken: Token): Unit = {
       token = lastToken
       if (next.token != EMPTY && !ctx.reporter.hasErrors)
         error("unexpected end of input: possible missing '}' in XML block")
@@ -1004,5 +1003,5 @@ object Scanners {
 
   // ------------- keyword configuration -----------------------------------
 
-  val (lastKeywordStart, kwArray) = buildKeywordArray(keywords)
+  private val (lastKeywordStart, kwArray) = buildKeywordArray(keywords)
 }
diff --git a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
index ba5027dd0824..66b235fdc9e4 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
@@ -13,14 +13,14 @@ abstract class TokensCommon {
 
   def tokenRange(lo: Int, hi: Int): TokenSet = BitSet(lo to hi: _*)
 
-  def showTokenDetailed(token: Int) = debugString(token)
+  def showTokenDetailed(token: Int): String = debugString(token)
 
-  def showToken(token: Int) = {
+  def showToken(token: Int): String = {
     val str = tokenString(token)
     if (isKeyword(token)) s"'$str'" else str
   }
 
-  val tokenString, debugString = new Array[String](maxToken + 1)
+  val tokenString, debugString: Array[String] = new Array[String](maxToken + 1)
 
   def enter(token: Int, str: String, debugStr: String = ""): Unit = {
     assert(tokenString(token) == null)
@@ -128,7 +128,7 @@ abstract class TokensCommon {
   final val firstParen = LPAREN
   final val lastParen = RBRACE
 
-  def buildKeywordArray(keywords: TokenSet) = {
+  def buildKeywordArray(keywords: TokenSet): (Int, Array[Int]) = {
     def start(tok: Token) = tokenString(tok).toTermName.asSimpleName.start
     def sourceKeywords = keywords.toList.filter { (kw: Token) =>
       val ts = tokenString(kw)
@@ -145,16 +145,16 @@ abstract class TokensCommon {
 
 object Tokens extends TokensCommon {
   final val minToken = EMPTY
-  final def maxToken = XMLSTART
+  final def maxToken: Int = XMLSTART
 
   final val INTERPOLATIONID = 10;  enter(INTERPOLATIONID, "string interpolator")
   final val SYMBOLLIT = 11;        enter(SYMBOLLIT, "symbol literal") // TODO: deprecate
 
   final val BACKQUOTED_IDENT = 13; enter(BACKQUOTED_IDENT, "identifier", "backquoted ident")
 
-  final val identifierTokens = BitSet(IDENTIFIER, BACKQUOTED_IDENT)
+  final val identifierTokens: BitSet = BitSet(IDENTIFIER, BACKQUOTED_IDENT)
 
-  def isIdentifier(token : Int) =
+  def isIdentifier(token : Int): Boolean =
     token >= IDENTIFIER && token <= BACKQUOTED_IDENT
 
   /** alphabetic keywords */
@@ -197,52 +197,52 @@ object Tokens extends TokensCommon {
   /** XML mode */
   final val XMLSTART = 96;         enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate
 
-  final val alphaKeywords = tokenRange(IF, ERASED)
-  final val symbolicKeywords = tokenRange(USCORE, VIEWBOUND)
-  final val symbolicTokens = tokenRange(COMMA, VIEWBOUND)
-  final val keywords = alphaKeywords | symbolicKeywords
+  final val alphaKeywords: TokenSet = tokenRange(IF, ERASED)
+  final val symbolicKeywords: TokenSet = tokenRange(USCORE, VIEWBOUND)
+  final val symbolicTokens: TokenSet = tokenRange(COMMA, VIEWBOUND)
+  final val keywords: BitSet = alphaKeywords | symbolicKeywords
 
-  final val allTokens = tokenRange(minToken, maxToken)
+  final val allTokens: TokenSet = tokenRange(minToken, maxToken)
 
-  final val simpleLiteralTokens = tokenRange(CHARLIT, STRINGLIT) | BitSet(TRUE, FALSE, SYMBOLLIT)
-  final val literalTokens = simpleLiteralTokens | BitSet(INTERPOLATIONID, NULL)
+  final val simpleLiteralTokens: BitSet = tokenRange(CHARLIT, STRINGLIT) | BitSet(TRUE, FALSE, SYMBOLLIT)
+  final val literalTokens: BitSet = simpleLiteralTokens | BitSet(INTERPOLATIONID, NULL)
 
-  final val atomicExprTokens = literalTokens | identifierTokens | BitSet(
+  final val atomicExprTokens: BitSet = literalTokens | identifierTokens | BitSet(
     USCORE, NULL, THIS, SUPER, TRUE, FALSE, RETURN, XMLSTART)
 
-  final val canStartExpressionTokens = atomicExprTokens | BitSet(
+  final val canStartExpressionTokens: BitSet = atomicExprTokens | BitSet(
     LBRACE, LPAREN, QBRACE, QPAREN, IF, DO, WHILE, FOR, NEW, TRY, THROW)
 
-  final val canStartTypeTokens = literalTokens | identifierTokens | BitSet(
+  final val canStartTypeTokens: BitSet = literalTokens | identifierTokens | BitSet(
     THIS, SUPER, USCORE, LPAREN, AT)
 
-  final val canStartBindingTokens = identifierTokens | BitSet(USCORE, LPAREN)
+  final val canStartBindingTokens: BitSet = identifierTokens | BitSet(USCORE, LPAREN)
 
-  final val templateIntroTokens = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
+  final val templateIntroTokens: BitSet = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
 
-  final val dclIntroTokens = BitSet(DEF, VAL, VAR, TYPE)
+  final val dclIntroTokens: BitSet = BitSet(DEF, VAL, VAR, TYPE)
 
-  final val defIntroTokens = templateIntroTokens | dclIntroTokens
+  final val defIntroTokens: BitSet = templateIntroTokens | dclIntroTokens
 
-  final val localModifierTokens = BitSet(
+  final val localModifierTokens: BitSet = BitSet(
     ABSTRACT, FINAL, SEALED, IMPLICIT, LAZY, ERASED)
 
-  final val accessModifierTokens = BitSet(
+  final val accessModifierTokens: BitSet = BitSet(
     PRIVATE, PROTECTED)
 
-  final val modifierTokens = localModifierTokens | accessModifierTokens | BitSet(
+  final val modifierTokens: BitSet = localModifierTokens | accessModifierTokens | BitSet(
     OVERRIDE)
 
-  final val modifierTokensOrCase = modifierTokens | BitSet(CASE)
+  final val modifierTokensOrCase: BitSet = modifierTokens | BitSet(CASE)
 
   /** Is token only legal as start of statement (eof also included)? */
-  final val mustStartStatTokens = defIntroTokens | modifierTokens | BitSet(IMPORT, PACKAGE)
+  final val mustStartStatTokens: BitSet = defIntroTokens | modifierTokens | BitSet(IMPORT, PACKAGE)
 
-  final val canStartStatTokens = canStartExpressionTokens | mustStartStatTokens | BitSet(
+  final val canStartStatTokens: BitSet = canStartExpressionTokens | mustStartStatTokens | BitSet(
     AT, CASE)
 
-  final val canEndStatTokens = atomicExprTokens | BitSet(
+  final val canEndStatTokens: BitSet = atomicExprTokens | BitSet(
     TYPE, RPAREN, RBRACE, RBRACKET)
 
-  final val numericLitTokens = BitSet(INTLIT, LONGLIT, FLOATLIT, DOUBLELIT)
+  final val numericLitTokens: BitSet = BitSet(INTLIT, LONGLIT, FLOATLIT, DOUBLELIT)
 }
diff --git a/compiler/src/dotty/tools/dotc/parsing/package.scala b/compiler/src/dotty/tools/dotc/parsing/package.scala
index 5ba02fd1d3bb..5a0bde20bd0f 100644
--- a/compiler/src/dotty/tools/dotc/parsing/package.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/package.scala
@@ -33,8 +33,8 @@ package object parsing {
       }
     }
 
-  def minPrec = 0
-  def minInfixPrec = 1
-  def maxPrec = 11
+  def minPrec: Int = 0
+  def minInfixPrec: Int = 1
+  def maxPrec: Int = 11
 
 }
diff --git a/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParserCommon.scala b/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParserCommon.scala
index a2ef15336ed2..5d0961206d4b 100644
--- a/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParserCommon.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParserCommon.scala
@@ -19,7 +19,7 @@ import util.Chars.SU
  *  All members should be accessed through those.
  */
 private[dotty] trait MarkupParserCommon {
-  protected def unreachable = scala.sys.error("Cannot be reached.")
+  protected def unreachable: Nothing = scala.sys.error("Cannot be reached.")
 
   // type HandleType       // MarkupHandler, SymbolicXMLBuilder
   type InputType        // Source, CharArrayReader
@@ -199,13 +199,13 @@ private[dotty] trait MarkupParserCommon {
   def xToken(that: Seq[Char]): Unit = { that foreach xToken }
 
   /** scan [S] '=' [S]*/
-  def xEQ() = { xSpaceOpt(); xToken('='); xSpaceOpt() }
+  def xEQ(): Unit = { xSpaceOpt(); xToken('='); xSpaceOpt() }
 
   /** skip optional space S? */
-  def xSpaceOpt() = while (isSpace(ch) && !eof) nextch()
+  def xSpaceOpt(): Unit = while (isSpace(ch) && !eof) nextch()
 
   /** scan [3] S ::= (#x20 | #x9 | #xD | #xA)+ */
-  def xSpace() =
+  def xSpace(): Unit =
     if (isSpace(ch)) { nextch(); xSpaceOpt() }
     else xHandleError(ch, "whitespace expected")
 
diff --git a/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala b/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala
index 88789d6a5bb4..5f4e8c1096d9 100644
--- a/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/xml/MarkupParsers.scala
@@ -35,15 +35,15 @@ object MarkupParsers {
   import ast.untpd._
 
   case object MissingEndTagControl extends ControlThrowable {
-    override def getMessage = "start tag was here: "
+    override def getMessage: String = "start tag was here: "
   }
 
   case object ConfusedAboutBracesControl extends ControlThrowable {
-    override def getMessage = " I encountered a '}' where I didn't expect one, maybe this tag isn't closed <"
+    override def getMessage: String = " I encountered a '}' where I didn't expect one, maybe this tag isn't closed <"
   }
 
   case object TruncatedXMLControl extends ControlThrowable {
-    override def getMessage = "input ended while parsing XML"
+    override def getMessage: String = "input ended while parsing XML"
   }
 
   class MarkupParser(parser: Parser, final val preserveWS: Boolean) extends MarkupParserCommon {
@@ -58,10 +58,10 @@ object MarkupParsers {
 
     def mkAttributes(name: String, other: NamespaceType): AttributesType = xAttributes
 
-    val eof = false
+    def eof: Boolean = false
 
     def truncatedError(msg: String): Nothing = throw TruncatedXMLControl
-    def xHandleError(that: Char, msg: String) =
+    def xHandleError(that: Char, msg: String): Unit =
       if (ch == SU) throw TruncatedXMLControl
       else reportSyntaxError(msg)
 
@@ -73,7 +73,7 @@ object MarkupParsers {
 
     def curOffset : Int = input.charOffset - 1
     var tmppos : Position = NoPosition
-    def ch = input.ch
+    def ch: Char = input.ch
     /** this method assign the next character to ch and advances in input */
     def nextch(): Unit = { input.nextChar() }
 
@@ -84,7 +84,7 @@ object MarkupParsers {
     def mkProcInstr(position: Position, name: String, text: String): ElementType =
       parser.symbXMLBuilder.procInstr(position, name, text)
 
-    var xEmbeddedBlock = false
+    var xEmbeddedBlock: Boolean = false
 
     private[this] var debugLastStartElement = List.empty[(Int, String)]
     private def debugLastPos = debugLastStartElement.head._1
@@ -94,7 +94,7 @@ object MarkupParsers {
       reportSyntaxError("in XML content, please use '}}' to express '}'")
       throw ConfusedAboutBracesControl
     }
-    def errorNoEnd(tag: String) = {
+    def errorNoEnd(tag: String): Nothing = {
       reportSyntaxError("expected closing tag of " + tag)
       throw MissingEndTagControl
     }
@@ -114,7 +114,7 @@ object MarkupParsers {
      *                      | `"` { _ } `"`
      *                      | `{` scalablock `}`
      */
-    def xAttributes = {
+    def xAttributes: mutable.LinkedHashMap[String, Tree] = {
       val aMap = mutable.LinkedHashMap[String, Tree]()
 
       while (isNameStart(ch)) {
@@ -392,7 +392,7 @@ object MarkupParsers {
       msg => parser.syntaxError(msg, curOffset)
     )
 
-    def escapeToScala[A](op: => A, kind: String) = {
+    def escapeToScala[A](op: => A, kind: String): A = {
       xEmbeddedBlock = false
       val res = saving[List[Int], A](parser.in.sepRegions, parser.in.sepRegions = _) {
         parser.in resume LBRACE
@@ -410,7 +410,7 @@ object MarkupParsers {
      */
     def xScalaPatterns: List[Tree] = escapeToScala(parser.patterns(), "pattern")
 
-    def reportSyntaxError(pos: Int, str: String) = parser.syntaxError(str, pos)
+    def reportSyntaxError(pos: Int, str: String): Unit = parser.syntaxError(str, pos)
     def reportSyntaxError(str: String): Unit = {
       reportSyntaxError(curOffset, "in XML literal: " + str)
       nextch()
diff --git a/compiler/src/dotty/tools/dotc/parsing/xml/SymbolicXMLBuilder.scala b/compiler/src/dotty/tools/dotc/parsing/xml/SymbolicXMLBuilder.scala
index 663cd48203c2..32a2bbbc714e 100644
--- a/compiler/src/dotty/tools/dotc/parsing/xml/SymbolicXMLBuilder.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/xml/SymbolicXMLBuilder.scala
@@ -11,7 +11,6 @@ import Names._, StdNames._, ast.Trees._, ast.{tpd, untpd}
 import Symbols._, Contexts._
 import util.Positions._
 import Parsers.Parser
-import scala.language.implicitConversions
 
 /** This class builds instance of `Tree` that represent XML.
  *
@@ -109,7 +108,7 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(implicit ctx: Cont
     atPos(pos) { if (isPattern) pat else nonpat }
   }
 
-  final def entityRef(pos: Position, n: String) =
+  final def entityRef(pos: Position, n: String): Tree =
     atPos(pos)( New(_scala_xml_EntityRef, LL(const(n))) )
 
   // create scala.xml.Text here <: scala.xml.Node
@@ -118,16 +117,16 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(implicit ctx: Cont
     else makeText1(const(txt))
   }
 
-  def makeTextPat(txt: Tree)                = Apply(_scala_xml__Text, List(txt))
-  def makeText1(txt: Tree)                  = New(_scala_xml_Text, LL(txt))
-  def comment(pos: Position, text: String)  = atPos(pos)( Comment(const(text)) )
-  def charData(pos: Position, txt: String)  = atPos(pos)( makeText1(const(txt)) )
+  def makeTextPat(txt: Tree): Apply               = Apply(_scala_xml__Text, List(txt))
+  def makeText1(txt: Tree): Tree                  = New(_scala_xml_Text, LL(txt))
+  def comment(pos: Position, text: String): Tree  = atPos(pos)( Comment(const(text)) )
+  def charData(pos: Position, txt: String): Tree  = atPos(pos)( makeText1(const(txt)) )
 
-  def procInstr(pos: Position, target: String, txt: String) =
+  def procInstr(pos: Position, target: String, txt: String): Tree =
     atPos(pos)( ProcInstr(const(target), const(txt)) )
 
-  protected def Comment(txt: Tree)                  = New(_scala_xml_Comment, LL(txt))
-  protected def ProcInstr(target: Tree, txt: Tree)  = New(_scala_xml_ProcInstr, LL(target, txt))
+  protected def Comment(txt: Tree): Tree                  = New(_scala_xml_Comment, LL(txt))
+  protected def ProcInstr(target: Tree, txt: Tree): Tree  = New(_scala_xml_ProcInstr, LL(target, txt))
 
   /** @todo: attributes */
   def makeXMLpat(pos: Position, n: String, args: Seq[Tree]): Tree = {
@@ -154,13 +153,13 @@ class SymbolicXMLBuilder(parser: Parser, preserveWS: Boolean)(implicit ctx: Cont
     }
   }
 
-  def isEmptyText(t: Tree) = t match {
+  def isEmptyText(t: Tree): Boolean = t match {
     case Literal(Constant("")) => true
     case _ => false
   }
 
   /** could optimize if args.length == 0, args.length == 1 AND args(0) is <: Node. */
-  def makeXMLseq(pos: Position, args: Seq[Tree]) = {
+  def makeXMLseq(pos: Position, args: Seq[Tree]): Block = {
     val buffer = ValDef(_buf, TypeTree(), New(_scala_xml_NodeBuffer, ListOfNil))
     val applies = args filterNot isEmptyText map (t => Apply(Select(Ident(_buf), _plus), List(t)))
 
diff --git a/compiler/src/dotty/tools/dotc/parsing/xml/Utility.scala b/compiler/src/dotty/tools/dotc/parsing/xml/Utility.scala
index 74f102054dcf..50cee13c9e1a 100644
--- a/compiler/src/dotty/tools/dotc/parsing/xml/Utility.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/xml/Utility.scala
@@ -128,7 +128,7 @@ object Utility {
    *  }}}
    *  See [4] and Appendix B of XML 1.0 specification.
   */
-  def isNameChar(ch: Char) = {
+  def isNameChar(ch: Char): Boolean = {
     import java.lang.Character._
     // The constants represent groups Mc, Me, Mn, Lm, and Nd.
 
@@ -149,7 +149,7 @@ object Utility {
    *  We do not allow a name to start with `:`.
    *  See [3] and Appendix B of XML 1.0 specification
    */
-  def isNameStart(ch: Char) = {
+  def isNameStart(ch: Char): Boolean = {
     import java.lang.Character._
 
     getType(ch).toByte match {
@@ -165,7 +165,7 @@ object Utility {
    *  }}}
    *  See [5] of XML 1.0 specification.
    */
-  def isName(s: String) =
+  def isName(s: String): Boolean =
     s.nonEmpty && isNameStart(s.head) && (s.tail forall isNameChar)
 
 }
diff --git a/compiler/src/dotty/tools/dotc/plugins/Plugins.scala b/compiler/src/dotty/tools/dotc/plugins/Plugins.scala
index 1b19df3068aa..734208ce51be 100644
--- a/compiler/src/dotty/tools/dotc/plugins/Plugins.scala
+++ b/compiler/src/dotty/tools/dotc/plugins/Plugins.scala
@@ -8,7 +8,6 @@ import dotty.tools.io._
 import Phases._
 import config.Printers.plugins.{ println => debug }
 
-import scala.collection.mutable.ListBuffer
 
 /** Support for run-time loading of compiler plugins.
  *
diff --git a/compiler/src/dotty/tools/dotc/printing/DecompilerPrinter.scala b/compiler/src/dotty/tools/dotc/printing/DecompilerPrinter.scala
index fe03355800e5..7d1ebde30bdf 100644
--- a/compiler/src/dotty/tools/dotc/printing/DecompilerPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/DecompilerPrinter.scala
@@ -10,7 +10,6 @@ import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.StdNames._
 
-import scala.language.implicitConversions
 
 class DecompilerPrinter(_ctx: Context) extends RefinedPrinter(_ctx) {
 
diff --git a/compiler/src/dotty/tools/dotc/printing/Formatting.scala b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
index e8090ddede13..1c4d9c3e1283 100644
--- a/compiler/src/dotty/tools/dotc/printing/Formatting.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Formatting.scala
@@ -2,16 +2,13 @@ package dotty.tools.dotc
 package printing
 
 import core._
-import Texts._, Types._, Flags._, Names._, Symbols._, NameOps._, Contexts._
+import Texts._, Types._, Flags._, Symbols._, Contexts._
 import collection.mutable
-import collection.Map
 import Decorators._
-import scala.annotation.switch
 import scala.util.control.NonFatal
 import reporting.diagnostic.MessageContainer
 import util.DiffUtil
 import Highlighting._
-import SyntaxHighlighting._
 
 object Formatting {
 
diff --git a/compiler/src/dotty/tools/dotc/printing/Highlighting.scala b/compiler/src/dotty/tools/dotc/printing/Highlighting.scala
index cdc1d966be4b..1b2236d96880 100644
--- a/compiler/src/dotty/tools/dotc/printing/Highlighting.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Highlighting.scala
@@ -10,11 +10,11 @@ object Highlighting {
   abstract class Highlight(private val highlight: String) {
     def text: String
 
-    def show(implicit ctx: Context) =
+    def show(implicit ctx: Context): String =
       if (ctx.settings.color.value == "never") text
       else highlight + text + Console.RESET
 
-    override def toString =
+    override def toString: String =
       highlight + text + Console.RESET
 
     def +(other: Highlight)(implicit ctx: Context): HighlightBuffer =
@@ -25,13 +25,13 @@ object Highlighting {
   }
 
   abstract class Modifier(private val mod: String, text: String) extends Highlight(Console.RESET) {
-    override def show(implicit ctx: Context) =
+    override def show(implicit ctx: Context): String =
       if (ctx.settings.color.value == "never") ""
       else mod + super.show
   }
 
   case class HighlightBuffer(hl: Highlight)(implicit ctx: Context) {
-    val buffer = new mutable.ListBuffer[String]
+    private[this] val buffer: mutable.ListBuffer[String] = new mutable.ListBuffer[String]
 
     buffer += hl.show
 
@@ -45,7 +45,7 @@ object Highlighting {
       this
     }
 
-    override def toString =
+    override def toString: String =
       buffer.mkString
   }
 
diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index 19ed444e5e7a..a0ca1c3fa303 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -4,11 +4,10 @@ package printing
 import core._
 import Texts._, Types._, Flags._, Names._, Symbols._, NameOps._, Constants._, Denotations._
 import Contexts.Context, Scopes.Scope, Denotations.Denotation, Annotations.Annotation
-import StdNames.{nme, tpnme}
-import ast.Trees._, ast._
+import StdNames.nme
+import ast.Trees._
 import typer.Implicits._
 import typer.ImportInfo
-import config.Config
 import java.lang.Integer.toOctalString
 import config.Config.summarizeDepth
 import scala.util.control.NonFatal
@@ -19,7 +18,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   private[this] var openRecs: List[RecType] = Nil
 
-  protected def maxToTextRecursions = 100
+  protected def maxToTextRecursions: Int = 100
 
   protected final def controlled(op: => Text): Text =
     if (ctx.base.toTextRecursions < maxToTextRecursions && ctx.base.toTextRecursions < maxSummarized)
@@ -35,7 +34,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
       "..."
     }
 
-  protected def recursionLimitExceeded() = {
+  protected def recursionLimitExceeded(): Unit = {
     ctx.warning("Exceeded recursion depth attempting to print.")
     if (ctx.debug) Thread.dumpStack()
   }
@@ -82,7 +81,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
    *  "package", etc.  The kind string, if non-empty, will be phrased relative
    *  to the name of the owner.
    */
-  protected def hasMeaninglessName(sym: Symbol) = (
+  protected def hasMeaninglessName(sym: Symbol): Boolean = (
        (sym is Param) && sym.owner.isSetter    // x$1
     || sym.isClassConstructor                  // this
     || (sym.name == nme.PACKAGE)               // package
@@ -95,10 +94,10 @@ class PlainPrinter(_ctx: Context) extends Printer {
   /** String representation of a name used in a refinement
    *  In refined printing this undoes type parameter expansion
    */
-  protected def refinementNameString(tp: RefinedType) = nameString(tp.refinedName)
+  protected def refinementNameString(tp: RefinedType): String = nameString(tp.refinedName)
 
   /** String representation of a refinement */
-  protected def toTextRefinement(rt: RefinedType) =
+  protected def toTextRefinement(rt: RefinedType): Closed =
     (refinementNameString(rt) ~ toTextRHS(rt.refinedInfo)).close
 
   protected def argText(arg: Type): Text = homogenizeArg(arg) match {
@@ -257,13 +256,13 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   protected def fullNameOwner(sym: Symbol): Symbol = sym.effectiveOwner.enclosingClass
 
-  protected def objectPrefix = "object "
-  protected def packagePrefix = "package "
+  protected def objectPrefix: String = "object "
+  protected def packagePrefix: String = "package "
 
-  protected def trimPrefix(text: Text) =
+  protected def trimPrefix(text: Text): Text =
     text.stripPrefix(objectPrefix).stripPrefix(packagePrefix)
 
-  protected def selectionString(tp: NamedType) = {
+  protected def selectionString(tp: NamedType): String = {
     val sym = if (homogenizedView) tp.symbol else tp.currentSymbol
     if (sym.exists) nameString(sym) else nameString(tp.name)
   }
@@ -542,7 +541,7 @@ class PlainPrinter(_ctx: Context) extends Printer {
 
   def summarized[T](op: => T): T = summarized(summarizeDepth)(op)
 
-  def plain = this
+  def plain: PlainPrinter = this
 
   protected def keywordStr(text: String): String = coloredStr(text, SyntaxHighlighting.KeywordColor)
   protected def keywordText(text: String): Text = coloredStr(text, SyntaxHighlighting.KeywordColor)
diff --git a/compiler/src/dotty/tools/dotc/printing/Printer.scala b/compiler/src/dotty/tools/dotc/printing/Printer.scala
index 8e72a8a5e477..988475d94faf 100644
--- a/compiler/src/dotty/tools/dotc/printing/Printer.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Printer.scala
@@ -4,7 +4,7 @@ package printing
 
 import core._
 import Texts._, ast.Trees._
-import Types.Type, Symbols.Symbol, Contexts.Context, Scopes.Scope, Constants.Constant,
+import Types.Type, Symbols.Symbol, Scopes.Scope, Constants.Constant,
        Names.Name, Denotations._, Annotations.Annotation
 import typer.Implicits.SearchResult
 import typer.ImportInfo
@@ -22,7 +22,7 @@ abstract class Printer {
    *  so that pretty-printing expressions using lower-precedence operators can insert parentheses automatically
    *  by calling `changePrec`.
    */
-  def currentPrecedence = prec
+  def currentPrecedence: Precedence = prec
 
   /** Generate text using `op`, assuming a given precedence level `prec`.
    *
@@ -149,15 +149,15 @@ abstract class Printer {
     atPrec(GlobalPrec) { elem.toText(this) }
 
   /** Render elements alternating with `sep` string */
-  def toText(elems: Traversable[Showable], sep: String) =
+  def toText(elems: Traversable[Showable], sep: String): Text =
     Text(elems map (_ toText this), sep)
 
   /** Render elements within highest precedence */
-  def toTextLocal(elems: Traversable[Showable], sep: String) =
+  def toTextLocal(elems: Traversable[Showable], sep: String): Text =
     atPrec(DotPrec) { toText(elems, sep) }
 
   /** Render elements within lowest precedence */
-  def toTextGlobal(elems: Traversable[Showable], sep: String) =
+  def toTextGlobal(elems: Traversable[Showable], sep: String): Text =
     atPrec(GlobalPrec) { toText(elems, sep) }
 
   /** Perform string or text-producing operation `op` so that only a
diff --git a/compiler/src/dotty/tools/dotc/printing/Printers.scala b/compiler/src/dotty/tools/dotc/printing/Printers.scala
index 36043a4ff7e2..1dc286ba590b 100644
--- a/compiler/src/dotty/tools/dotc/printing/Printers.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Printers.scala
@@ -6,7 +6,7 @@ import core.Contexts.Context
 trait Printers { this: Context =>
 
   /** A function creating a printer */
-  def printer = {
+  def printer: Printer = {
     val pr = printerFn(this)
     if (this.settings.YplainPrinter.value) pr.plain else pr
   }
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index b0c3a42abcc0..0865b6103ed4 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -8,30 +8,21 @@ import Flags._
 import Names._
 import Symbols._
 import NameOps._
-import Constants._
 import TypeErasure.ErasedValueType
 import Contexts.Context
-import Scopes.Scope
 import Denotations._
 import SymDenotations._
-import Annotations.Annotation
 import StdNames.{nme, tpnme}
-import ast.{Trees, tpd, untpd}
-import typer.{Implicits, Inliner, Namer}
+import ast.{Trees, untpd}
+import typer.{Implicits, Namer}
 import typer.ProtoTypes._
 import Trees._
 import TypeApplications._
 import Decorators._
-import config.Config
-import util.Positions._
-import transform.SymUtils._
 import transform.TypeUtils._
-import dotty.tools.dotc.transform.FirstTransform
 
-import scala.annotation.switch
 import language.implicitConversions
 import dotty.tools.dotc.util.SourcePosition
-import Highlighting._
 import dotty.tools.dotc.ast.untpd.{MemberDef, Modifiers, PackageDef, RefTree, Template, TypeDef, ValOrDefDef}
 
 class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
@@ -68,15 +59,15 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     try op finally printPos = savedPrintPos
   }
 
-  protected def enclDefIsClass = enclosingDef match {
+  protected def enclDefIsClass: Boolean = enclosingDef match {
     case owner: TypeDef => owner.isClassDef
     case owner: untpd.ModuleDef => true
     case _ => false
   }
 
-  override protected def recursionLimitExceeded() = {}
+  override protected def recursionLimitExceeded(): Unit = {}
 
-  protected val PrintableFlags = (SourceModifierFlags | Label | Module | Local).toCommonFlags
+  protected val PrintableFlags: FlagSet = (SourceModifierFlags | Label | Module | Local).toCommonFlags
 
   override def nameString(name: Name): String =
     if (ctx.settings.YdebugNames.value) name.debugString else name.toString
@@ -88,7 +79,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     if (isEmptyPrefix(sym.maybeOwner)) nameString(sym)
     else super.fullNameString(sym)
 
-  override protected def fullNameOwner(sym: Symbol) = {
+  override protected def fullNameOwner(sym: Symbol): Symbol = {
     val owner = super.fullNameOwner(sym)
     if (owner is ModuleClass) owner.sourceModule else owner
   }
@@ -623,7 +614,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     if (sym.privateWithin.exists) sym.privateWithin.asType.name else tpnme.EMPTY,
     sym.annotations map (_.tree))
 
-  protected def optAscription[T >: Untyped](tpt: Tree[T]) = optText(tpt)(": " ~ _)
+  protected def optAscription[T >: Untyped](tpt: Tree[T]): Text = 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 ""
@@ -647,7 +638,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   private def toTextOwner(tree: Tree[_]) =
     "[owner = " ~ tree.symbol.maybeOwner.show ~ "]" provided ctx.settings.YprintDebugOwners.value
 
-  protected def dclTextOr[T >: Untyped](tree: Tree[T])(treeText: => Text) =
+  protected def dclTextOr[T >: Untyped](tree: Tree[T])(treeText: => Text): Text =
     toTextOwner(tree) ~ {
       if (useSymbol(tree)) annotsText(tree.symbol) ~~ dclText(tree.symbol)
       else treeText
@@ -660,7 +651,7 @@ 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 => _, _}
+    import untpd.{modsDeco => _}
     dclTextOr(tree) {
       modText(tree.mods, tree.symbol, keywordStr(if (tree.mods is Mutable) "var" else "val")) ~~
         valDefText(nameIdText(tree)) ~ optAscription(tree.tpt) ~
@@ -669,7 +660,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
   }
 
   protected def defDefToText[T >: Untyped](tree: DefDef[T]): Text = {
-    import untpd.{modsDeco => _, _}
+    import untpd.{modsDeco => _}
     dclTextOr(tree) {
       val prefix = modText(tree.mods, tree.symbol, keywordStr("def")) ~~ valDefText(nameIdText(tree))
       withEnclosingDef(tree) {
@@ -767,7 +758,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
   override protected def treatAsTypeParam(sym: Symbol): Boolean = sym is TypeParam
 
-  override protected def treatAsTypeArg(sym: Symbol) =
+  override protected def treatAsTypeArg(sym: Symbol): Boolean =
     sym.isType && (sym is ProtectedLocal) &&
       (sym.allOverriddenSymbols exists (_ is TypeParam))
 
@@ -788,7 +779,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       super.toText(sym)
   }
 
-  override def kindString(sym: Symbol) = {
+  override def kindString(sym: Symbol): String = {
     val flags = sym.flagsUNSAFE
     if (flags is Package) "package"
     else if (sym.isPackageObject) "package object"
@@ -810,7 +801,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
     else super.keyString(sym)
   }
 
-  override def toTextFlags(sym: Symbol) =
+  override def toTextFlags(sym: Symbol): Text =
     if (ctx.settings.YdebugFlags.value)
       super.toTextFlags(sym)
     else {
@@ -827,7 +818,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       else "some " ~ toText(denot.info)
   }
 
-  override def plain = new PlainPrinter(_ctx)
+  override def plain: PlainPrinter = new PlainPrinter(_ctx)
 
   private def withPos(txt: Text, pos: SourcePosition): Text = {
     if (!printLines || !pos.exists) txt
diff --git a/compiler/src/dotty/tools/dotc/printing/ReplPrinter.scala b/compiler/src/dotty/tools/dotc/printing/ReplPrinter.scala
index 700bc8bcccb4..a66555423e64 100644
--- a/compiler/src/dotty/tools/dotc/printing/ReplPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/ReplPrinter.scala
@@ -7,10 +7,9 @@ import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.NameOps._
 import dotty.tools.dotc.core.Names.Name
 import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Types.{ExprType, TypeAlias}
+import dotty.tools.dotc.core.Types.ExprType
 import dotty.tools.dotc.printing.Texts._
 
-import scala.language.implicitConversions
 
 class ReplPrinter(_ctx: Context) extends DecompilerPrinter(_ctx) {
 
diff --git a/compiler/src/dotty/tools/dotc/printing/Showable.scala b/compiler/src/dotty/tools/dotc/printing/Showable.scala
index efddb26f7f13..550d80060a15 100644
--- a/compiler/src/dotty/tools/dotc/printing/Showable.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Showable.scala
@@ -5,7 +5,6 @@ import core._
 
 import Contexts._, Texts._, Decorators._
 import config.Config.summarizeDepth
-import scala.util.control.NonFatal
 
 trait Showable extends Any {
 
diff --git a/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala b/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala
index 128a28b744fa..36659544d6ff 100644
--- a/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala
+++ b/compiler/src/dotty/tools/dotc/printing/SyntaxHighlighting.scala
@@ -7,7 +7,6 @@ import dotty.tools.dotc.parsing.Parsers.Parser
 import dotty.tools.dotc.parsing.Scanners.Scanner
 import dotty.tools.dotc.parsing.Tokens._
 import dotty.tools.dotc.reporting.Reporter
-import dotty.tools.dotc.reporting.diagnostic.MessageContainer
 import dotty.tools.dotc.util.Positions.Position
 import dotty.tools.dotc.util.SourceFile
 
@@ -20,14 +19,14 @@ object SyntaxHighlighting {
   private final val debug = true
 
   // Keep in sync with SyntaxHighlightingTests
-  val NoColor         = Console.RESET
-  val CommentColor    = Console.BLUE
-  val KeywordColor    = Console.YELLOW
-  val ValDefColor     = Console.CYAN
-  val LiteralColor    = Console.RED
-  val StringColor     = Console.GREEN
-  val TypeColor       = Console.MAGENTA
-  val AnnotationColor = Console.MAGENTA
+  val NoColor: String         = Console.RESET
+  val CommentColor: String    = Console.BLUE
+  val KeywordColor: String    = Console.YELLOW
+  val ValDefColor: String     = Console.CYAN
+  val LiteralColor: String    = Console.RED
+  val StringColor: String     = Console.GREEN
+  val TypeColor: String       = Console.MAGENTA
+  val AnnotationColor: String = Console.MAGENTA
 
   def highlight(in: String)(implicit ctx: Context): String = {
     def freshCtx = ctx.fresh.setReporter(Reporter.NoReporter)
diff --git a/compiler/src/dotty/tools/dotc/printing/Texts.scala b/compiler/src/dotty/tools/dotc/printing/Texts.scala
index d1758847ca20..20d01151a144 100644
--- a/compiler/src/dotty/tools/dotc/printing/Texts.scala
+++ b/compiler/src/dotty/tools/dotc/printing/Texts.scala
@@ -6,7 +6,7 @@ object Texts {
 
   sealed abstract class Text {
 
-    protected def indentMargin = 2
+    protected def indentMargin: Int = 2
 
     def relems: List[Text]
 
@@ -16,12 +16,12 @@ object Texts {
       case Vertical(relems) => relems.isEmpty
     }
 
-    def isVertical = isInstanceOf[Vertical]
-    def isClosed = isVertical || isInstanceOf[Closed]
-    def isFluid = isInstanceOf[Fluid]
-    def isSplittable = isFluid && !isClosed
+    def isVertical: Boolean = isInstanceOf[Vertical]
+    def isClosed: Boolean = isVertical || isInstanceOf[Closed]
+    def isFluid: Boolean = isInstanceOf[Fluid]
+    def isSplittable: Boolean = isFluid && !isClosed
 
-    def close = new Closed(relems)
+    def close: Closed = new Closed(relems)
 
     def remaining(width: Int): Int = this match {
       case Str(s, _) =>
@@ -135,17 +135,17 @@ object Texts {
       sb.toString
     }
 
-    def ~ (that: Text) =
+    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)
 
-    def over (that: Text) =
+    def over (that: Text): Vertical =
       if (this.isVertical) Vertical(that :: this.relems)
       else Vertical(that :: this :: Nil)
   }
@@ -168,7 +168,7 @@ object Texts {
     }
 
     /** The given texts `xs`, each on a separate line */
-    def lines(xs: Traversable[Text]) = Vertical(xs.toList.reverse)
+    def lines(xs: Traversable[Text]): Vertical = Vertical(xs.toList.reverse)
 
     implicit class textDeco(text: => Text) {
       def provided(cond: Boolean): Text = if (cond) text else Str("")
diff --git a/compiler/src/dotty/tools/dotc/printing/package.scala b/compiler/src/dotty/tools/dotc/printing/package.scala
index 80dfb5244d97..246bbd206d5e 100644
--- a/compiler/src/dotty/tools/dotc/printing/package.scala
+++ b/compiler/src/dotty/tools/dotc/printing/package.scala
@@ -1,26 +1,25 @@
 package dotty.tools.dotc
 
 import core.StdNames.{nme,tpnme}
-import parsing.{precedence, minPrec, maxPrec, minInfixPrec}
 import util.Property.Key
 
 package object printing {
 
   type Precedence = Int
 
-  val DotPrec       = parsing.maxPrec
-  val AndTypePrec   = parsing.precedence(tpnme.raw.AMP)
-  val OrTypePrec    = parsing.precedence(tpnme.raw.BAR)
-  val OrPrec        = parsing.precedence(nme.raw.BAR)
-  val InfixPrec     = parsing.minInfixPrec
-  val GlobalPrec    = parsing.minPrec
-  val TopLevelPrec  = parsing.minPrec - 1
+  val DotPrec: Int       = parsing.maxPrec
+  val AndTypePrec: Int   = parsing.precedence(tpnme.raw.AMP)
+  val OrTypePrec: Int    = parsing.precedence(tpnme.raw.BAR)
+  val OrPrec: Int        = parsing.precedence(nme.raw.BAR)
+  val InfixPrec: Int     = parsing.minInfixPrec
+  val GlobalPrec: Int    = parsing.minPrec
+  val TopLevelPrec: Int  = parsing.minPrec - 1
 
   /** A property to indicate whether the compiler is currently doing -Xprint
    *
    *  -Xprint will print `sym.name` instead of `sym.originalName`
    */
-  val XprintMode = new Key[Unit]
+  val XprintMode: Key[Unit] = new Key
 
   /** @pre `nel` is non-empty list */
   private[printing] implicit class ListOps[A](val nel: List[A]) extends AnyVal {
diff --git a/compiler/src/dotty/tools/dotc/profile/Profiler.scala b/compiler/src/dotty/tools/dotc/profile/Profiler.scala
index 07612788600c..ecb9696a7fd5 100644
--- a/compiler/src/dotty/tools/dotc/profile/Profiler.scala
+++ b/compiler/src/dotty/tools/dotc/profile/Profiler.scala
@@ -1,7 +1,7 @@
 package dotty.tools.dotc.profile
 
 import java.io.{FileWriter, PrintWriter}
-import java.lang.management.ManagementFactory
+import java.lang.management.{ManagementFactory, GarbageCollectorMXBean, RuntimeMXBean, MemoryMXBean, ClassLoadingMXBean, CompilationMXBean}
 import java.util.concurrent.TimeUnit
 import java.util.concurrent.atomic.AtomicInteger
 import javax.management.openmbean.CompositeData
@@ -9,6 +9,7 @@ import javax.management.{Notification, NotificationEmitter, NotificationListener
 
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.io.AbstractFile
 
 object Profiler {
   def apply()(implicit ctx: Context): Profiler =
@@ -20,7 +21,7 @@ object Profiler {
       new RealProfiler(reporter)
     }
 
-  private[profile] val emptySnap = ProfileSnap(0, "", 0, 0, 0, 0, 0, 0)
+  private[profile] val emptySnap: ProfileSnap = ProfileSnap(0, "", 0, 0, 0, 0, 0, 0)
 }
 
 case class GcEventData(pool:String, reportTimeNs: Long, gcStartMillis:Long, gcEndMillis:Long, name:String, action:String, cause:String, threads:Long)
@@ -28,20 +29,20 @@ case class GcEventData(pool:String, reportTimeNs: Long, gcStartMillis:Long, gcEn
 case class ProfileSnap(threadId: Long, threadName: String, snapTimeNanos : Long,
                        idleTimeNanos:Long, cpuTimeNanos: Long, userTimeNanos: Long,
                        allocatedBytes:Long, heapBytes:Long) {
-  def updateHeap(heapBytes:Long) = {
+  def updateHeap(heapBytes:Long): ProfileSnap = {
     copy(heapBytes = heapBytes)
   }
 }
 case class ProfileRange(start: ProfileSnap, end:ProfileSnap, phase:Phase, purpose:String, taskCount:Int, thread:Thread) {
-  def allocatedBytes = end.allocatedBytes - start.allocatedBytes
+  def allocatedBytes: Long = end.allocatedBytes - start.allocatedBytes
 
-  def userNs = end.userTimeNanos - start.userTimeNanos
+  def userNs: Long = end.userTimeNanos - start.userTimeNanos
 
-  def cpuNs = end.cpuTimeNanos - start.cpuTimeNanos
+  def cpuNs: Long = end.cpuTimeNanos - start.cpuTimeNanos
 
-  def idleNs = end.idleTimeNanos - start.idleTimeNanos
+  def idleNs: Long = end.idleTimeNanos - start.idleTimeNanos
 
-  def runNs = end.snapTimeNanos - start.snapTimeNanos
+  def runNs: Long = end.snapTimeNanos - start.snapTimeNanos
 
 
   private def toMillis(ns: Long) = ns / 1000000.0D
@@ -49,17 +50,17 @@ case class ProfileRange(start: ProfileSnap, end:ProfileSnap, phase:Phase, purpos
   private def toMegaBytes(bytes: Long) = bytes / 1000000.0D
 
 
-  def wallClockTimeMillis = toMillis(end.snapTimeNanos - start.snapTimeNanos)
+  def wallClockTimeMillis: Double = toMillis(end.snapTimeNanos - start.snapTimeNanos)
 
-  def idleTimeMillis = toMillis(end.idleTimeNanos - start.idleTimeNanos)
+  def idleTimeMillis: Double = toMillis(end.idleTimeNanos - start.idleTimeNanos)
 
-  def cpuTimeMillis = toMillis(end.cpuTimeNanos - start.cpuTimeNanos)
+  def cpuTimeMillis: Double = toMillis(end.cpuTimeNanos - start.cpuTimeNanos)
 
-  def userTimeMillis = toMillis(end.userTimeNanos - start.userTimeNanos)
+  def userTimeMillis: Double = toMillis(end.userTimeNanos - start.userTimeNanos)
 
-  def allocatedMB = toMegaBytes(end.allocatedBytes - start.allocatedBytes)
+  def allocatedMB: Double = toMegaBytes(end.allocatedBytes - start.allocatedBytes)
 
-  def retainedHeapMB = toMegaBytes(end.heapBytes - start.heapBytes)
+  def retainedHeapMB: Double = toMegaBytes(end.heapBytes - start.heapBytes)
 }
 
 sealed trait Profiler {
@@ -80,12 +81,12 @@ private [profile] object NoOpProfiler extends Profiler {
 }
 private [profile] object RealProfiler {
   import scala.collection.JavaConverters._
-  val runtimeMx = ManagementFactory.getRuntimeMXBean
-  val memoryMx = ManagementFactory.getMemoryMXBean
-  val gcMx = ManagementFactory.getGarbageCollectorMXBeans.asScala.toList
-  val classLoaderMx = ManagementFactory.getClassLoadingMXBean
-  val compileMx = ManagementFactory.getCompilationMXBean
-  val threadMx = ExtendedThreadMxBean.proxy
+  val runtimeMx: RuntimeMXBean = ManagementFactory.getRuntimeMXBean
+  val memoryMx: MemoryMXBean = ManagementFactory.getMemoryMXBean
+  val gcMx: List[GarbageCollectorMXBean] = ManagementFactory.getGarbageCollectorMXBeans.asScala.toList
+  val classLoaderMx: ClassLoadingMXBean = ManagementFactory.getClassLoadingMXBean
+  val compileMx: CompilationMXBean = ManagementFactory.getCompilationMXBean
+  val threadMx: ExtendedThreadMxBean = ExtendedThreadMxBean.proxy
   if (threadMx.isThreadCpuTimeSupported) threadMx.setThreadCpuTimeEnabled(true)
   private val idGen = new AtomicInteger()
 }
@@ -95,9 +96,9 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(implicit ctx: C
     reporter.reportBackground(this, threadRange)
   }
 
-  def outDir = ctx.settings.outputDir.value
+  def outDir: AbstractFile = ctx.settings.outputDir.value
 
-  val id = RealProfiler.idGen.incrementAndGet()
+  val id: Int = RealProfiler.idGen.incrementAndGet()
   RealProfiler.gcMx foreach {
     case emitter: NotificationEmitter => emitter.addNotificationListener(this, null, null)
     case gc => println(s"Cant connect gcListener to ${gc.getClass}")
@@ -193,11 +194,11 @@ private [profile] class RealProfiler(reporter : ProfileReporter)(implicit ctx: C
 case class EventType(name: String)
 object EventType {
   //main thread with other tasks
-  val MAIN = EventType("main")
+  val MAIN: EventType = EventType("main")
   //other task ( background thread)
-  val BACKGROUND = EventType("background")
+  val BACKGROUND: EventType = EventType("background")
   //total for compile
-  val GC = EventType("GC")
+  val GC: EventType = EventType("GC")
 }
 
 sealed trait ProfileReporter {
@@ -259,4 +260,4 @@ class StreamProfileReporter(out:PrintWriter) extends ProfileReporter {
     out.flush
     out.close
   }
-}
\ No newline at end of file
+}
diff --git a/compiler/src/dotty/tools/dotc/quoted/ExprCompilationUnit.scala b/compiler/src/dotty/tools/dotc/quoted/ExprCompilationUnit.scala
index 620ca7065f57..0dffbb82b7a3 100644
--- a/compiler/src/dotty/tools/dotc/quoted/ExprCompilationUnit.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/ExprCompilationUnit.scala
@@ -7,5 +7,5 @@ import scala.quoted.Expr
 
 /* Compilation unit containing the contents of a quoted expression */
 class ExprCompilationUnit(val expr: Expr[_]) extends CompilationUnit(NoSource) {
-  override def toString = s"Expr($expr)"
+  override def toString: String = s"Expr($expr)"
 }
diff --git a/compiler/src/dotty/tools/dotc/quoted/QuoteCompiler.scala b/compiler/src/dotty/tools/dotc/quoted/QuoteCompiler.scala
index a54cf8a3bd67..5f57cb7e9ff6 100644
--- a/compiler/src/dotty/tools/dotc/quoted/QuoteCompiler.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/QuoteCompiler.scala
@@ -1,7 +1,6 @@
 package dotty.tools.dotc
 package quoted
 
-import dotty.tools.backend.jvm.GenBCode
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Decorators._
@@ -18,7 +17,7 @@ import dotty.tools.dotc.transform.ReifyQuotes
 import dotty.tools.dotc.typer.FrontEnd
 import dotty.tools.dotc.util.Positions.Position
 import dotty.tools.dotc.util.SourceFile
-import dotty.tools.io.{AbstractFile, Path, PlainFile}
+import dotty.tools.io.{Path, PlainFile}
 
 import scala.quoted.{Expr, Type}
 
@@ -26,7 +25,6 @@ import scala.quoted.{Expr, Type}
  *  a class file with `class ' { def apply: Object = expr }`.
  */
 class QuoteCompiler extends Compiler {
-  import tpd._
 
   override protected def frontendPhases: List[List[Phase]] =
     List(List(new QuotedFrontend(putInClass = true)))
@@ -45,7 +43,7 @@ class QuoteCompiler extends Compiler {
   class QuotedFrontend(putInClass: Boolean) extends FrontEnd {
     import tpd._
 
-    override def isTyper = false
+    override def isTyper: Boolean = false
 
     override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
       units.map {
diff --git a/compiler/src/dotty/tools/dotc/quoted/TypeCompilationUnit.scala b/compiler/src/dotty/tools/dotc/quoted/TypeCompilationUnit.scala
index d2090b9ec336..725e6e366a27 100644
--- a/compiler/src/dotty/tools/dotc/quoted/TypeCompilationUnit.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/TypeCompilationUnit.scala
@@ -7,5 +7,5 @@ import scala.quoted.Type
 
 /* Compilation unit containing the contents of a quoted type */
 class TypeCompilationUnit(val tpe: Type[_]) extends CompilationUnit(NoSource) {
-  override def toString = s"Type($tpe)"
+  override def toString: String = s"Type($tpe)"
 }
diff --git a/compiler/src/dotty/tools/dotc/reporting/ConsoleReporter.scala b/compiler/src/dotty/tools/dotc/reporting/ConsoleReporter.scala
index eb40cab959a2..4d775eaa3bc5 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ConsoleReporter.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ConsoleReporter.scala
@@ -4,8 +4,8 @@ package reporting
 
 import core.Contexts._
 import java.io.{ BufferedReader, PrintWriter }
-import diagnostic.{ Message, MessageContainer }
-import diagnostic.messages.{ Error, Warning, ConditionalWarning }
+import diagnostic.MessageContainer
+import diagnostic.messages.{ Error, ConditionalWarning }
 
 /**
   * This class implements a Reporter that displays messages on a text console
diff --git a/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala b/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala
index 0cdf717c6f2f..85db42421550 100644
--- a/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/MessageRendering.scala
@@ -6,7 +6,7 @@ import core.Contexts.Context
 import core.Decorators._
 import printing.Highlighting.{Blue, Red}
 import printing.SyntaxHighlighting
-import diagnostic.{ErrorMessageID, Message, MessageContainer, NoExplanation}
+import diagnostic.{ErrorMessageID, Message, MessageContainer}
 import diagnostic.messages._
 import util.SourcePosition
 import util.Chars.{ LF, CR, FF, SU }
diff --git a/compiler/src/dotty/tools/dotc/reporting/Reporter.scala b/compiler/src/dotty/tools/dotc/reporting/Reporter.scala
index 4e556af7ea5c..1c6c60073a9f 100644
--- a/compiler/src/dotty/tools/dotc/reporting/Reporter.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/Reporter.scala
@@ -28,12 +28,11 @@ object Reporter {
 
   /** A reporter that ignores reports, and doesn't record errors */
   @sharable object NoReporter extends Reporter {
-    def doReport(m: MessageContainer)(implicit ctx: Context) = ()
+    def doReport(m: MessageContainer)(implicit ctx: Context): Unit = ()
     override def report(m: MessageContainer)(implicit ctx: Context): Unit = ()
   }
 }
 
-import Reporter._
 
 trait Reporting { this: Context =>
 
@@ -122,10 +121,10 @@ trait Reporting { this: Context =>
     informProgress(msg + elapsed)
   }
 
-  def informProgress(msg: => String) =
+  def informProgress(msg: => String): Unit =
     inform("[" + msg + "]")
 
-  def logWith[T](msg: => String)(value: T) = {
+  def logWith[T](msg: => String)(value: T): T = {
     log(msg + " " + value)
     value
   }
@@ -148,7 +147,7 @@ abstract class Reporter extends interfaces.ReporterResult {
    *  invisible due to the max message length.
    */
   private[this] var _truncationOK: Boolean = true
-  def truncationOK = _truncationOK
+  def truncationOK: Boolean = _truncationOK
   def withoutTruncating[T](body: => T): T = {
     val saved = _truncationOK
     _truncationOK = false
@@ -167,17 +166,17 @@ abstract class Reporter extends interfaces.ReporterResult {
 
   private[this] var _errorCount = 0
   private[this] var _warningCount = 0
-  def errorCount = _errorCount
-  def warningCount = _warningCount
-  def hasErrors = errorCount > 0
-  def hasWarnings = warningCount > 0
+  def errorCount: Int = _errorCount
+  def warningCount: Int = _warningCount
+  def hasErrors: Boolean = errorCount > 0
+  def hasWarnings: Boolean = warningCount > 0
   private[this] var errors: List[Error] = Nil
-  def allErrors = errors
+  def allErrors: List[Error] = errors
 
   /** Have errors been reported by this reporter, or in the
    *  case where this is a StoreReporter, by an outer reporter?
    */
-  def errorsReported = hasErrors
+  def errorsReported: Boolean = hasErrors
 
   private[this] var reportedFeaturesUseSites = Set[Symbol]()
 
@@ -186,7 +185,7 @@ abstract class Reporter extends interfaces.ReporterResult {
 
   def reportNewFeatureUseSite(featureTrait: Symbol): Unit = reportedFeaturesUseSites += featureTrait
 
-  val unreportedWarnings = new mutable.HashMap[String, Int] {
+  val unreportedWarnings: mutable.HashMap[String, Int] = new mutable.HashMap[String, Int] {
     override def default(key: String) = 0
   }
 
diff --git a/compiler/src/dotty/tools/dotc/reporting/StoreReporter.scala b/compiler/src/dotty/tools/dotc/reporting/StoreReporter.scala
index 4adf5405590a..e642e294fcf4 100644
--- a/compiler/src/dotty/tools/dotc/reporting/StoreReporter.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/StoreReporter.scala
@@ -35,5 +35,5 @@ class StoreReporter(outer: Reporter) extends Reporter {
     if (infos != null) try infos.toList finally infos = null
     else Nil
 
-  override def errorsReported = hasErrors || (outer != null && outer.errorsReported)
+  override def errorsReported: Boolean = hasErrors || (outer != null && outer.errorsReported)
 }
diff --git a/compiler/src/dotty/tools/dotc/reporting/ThrowingReporter.scala b/compiler/src/dotty/tools/dotc/reporting/ThrowingReporter.scala
index d8e03ab66ab8..758cc3733ad1 100644
--- a/compiler/src/dotty/tools/dotc/reporting/ThrowingReporter.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/ThrowingReporter.scala
@@ -3,10 +3,8 @@ package dotc
 package reporting
 
 import core.Contexts.Context
-import collection.mutable
 import diagnostic.MessageContainer
 import diagnostic.messages.Error
-import Reporter._
 
 /**
  * This class implements a Reporter that throws all errors and sends warnings and other
diff --git a/compiler/src/dotty/tools/dotc/reporting/UniqueMessagePositions.scala b/compiler/src/dotty/tools/dotc/reporting/UniqueMessagePositions.scala
index b7049f8038b6..4a69f4f6fd56 100644
--- a/compiler/src/dotty/tools/dotc/reporting/UniqueMessagePositions.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/UniqueMessagePositions.scala
@@ -3,7 +3,7 @@ package dotc
 package reporting
 
 import scala.collection.mutable
-import util.{SourcePosition, SourceFile}
+import util.SourceFile
 import core.Contexts.Context
 import diagnostic.MessageContainer
 
diff --git a/compiler/src/dotty/tools/dotc/reporting/diagnostic/Message.scala b/compiler/src/dotty/tools/dotc/reporting/diagnostic/Message.scala
index 74b4e1fe0194..48c5deaaa9a2 100644
--- a/compiler/src/dotty/tools/dotc/reporting/diagnostic/Message.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/diagnostic/Message.scala
@@ -4,7 +4,6 @@ package reporting
 package diagnostic
 
 import util.SourcePosition
-import core.Contexts.Context
 
 import messages._
 
@@ -23,7 +22,7 @@ object Message {
   * consumed by a subclass of `Reporter`. However, the error position is only
   * part of `MessageContainer`, not `Message`.
   *
-  * NOTE: you should not be persisting messages. Most messages take an implicit
+  * NOTE: you should not be persisting  Most messages take an implicit
   * `Context` and these contexts weigh in at about 4mb per instance, as such
   * persisting these will result in a memory leak.
   *
@@ -80,10 +79,10 @@ abstract class Message(val errorId: ErrorMessageID) { self =>
   * message.
   */
 class ExtendMessage(_msg: () => Message)(f: String => String) { self =>
-  lazy val msg = f(_msg().msg)
-  lazy val kind = _msg().kind
-  lazy val explanation = _msg().explanation
-  lazy val errorId = _msg().errorId
+  lazy val msg: String = f(_msg().msg)
+  lazy val kind: String = _msg().kind
+  lazy val explanation: String = _msg().explanation
+  lazy val errorId: ErrorMessageID = _msg().errorId
 
   private def toMessage = new Message(errorId) {
     val msg = self.msg
@@ -92,38 +91,38 @@ class ExtendMessage(_msg: () => Message)(f: String => String) { self =>
   }
 
   /** Enclose this message in an `Error` container */
-  def error(pos: SourcePosition) =
+  def error(pos: SourcePosition): Error =
     new Error(toMessage, pos)
 
   /** Enclose this message in an `Warning` container */
-  def warning(pos: SourcePosition) =
+  def warning(pos: SourcePosition): Warning =
     new Warning(toMessage, pos)
 
   /** Enclose this message in an `Info` container */
-  def info(pos: SourcePosition) =
+  def info(pos: SourcePosition): Info =
     new Info(toMessage, pos)
 
   /** Enclose this message in an `FeatureWarning` container */
-  def featureWarning(pos: SourcePosition) =
+  def featureWarning(pos: SourcePosition): FeatureWarning =
     new FeatureWarning(toMessage, pos)
 
   /** Enclose this message in an `UncheckedWarning` container */
-  def uncheckedWarning(pos: SourcePosition) =
+  def uncheckedWarning(pos: SourcePosition): UncheckedWarning =
     new UncheckedWarning(toMessage, pos)
 
   /** Enclose this message in an `DeprecationWarning` container */
-  def deprecationWarning(pos: SourcePosition) =
+  def deprecationWarning(pos: SourcePosition): DeprecationWarning =
     new DeprecationWarning(toMessage, pos)
 
   /** Enclose this message in an `MigrationWarning` container */
-  def migrationWarning(pos: SourcePosition) =
+  def migrationWarning(pos: SourcePosition): MigrationWarning =
     new MigrationWarning(toMessage, pos)
 }
 
 /** The fallback `Message` containing no explanation and having no `kind` */
 class NoExplanation(val msg: String) extends Message(ErrorMessageID.NoExplanationID) {
-  val explanation = ""
-  val kind = ""
+  val explanation: String = ""
+  val kind: String = ""
 
   override def toString(): String = s"NoExplanation($msg)"
 }
diff --git a/compiler/src/dotty/tools/dotc/reporting/diagnostic/MessageContainer.scala b/compiler/src/dotty/tools/dotc/reporting/diagnostic/MessageContainer.scala
index c2d94030ca0b..a72775c854f3 100644
--- a/compiler/src/dotty/tools/dotc/reporting/diagnostic/MessageContainer.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/diagnostic/MessageContainer.scala
@@ -9,8 +9,8 @@ import core.Contexts.Context
 import java.util.Optional
 
 object MessageContainer {
-  val nonSensicalStartTag = "<nonsensical>"
-  val nonSensicalEndTag = "</nonsensical>"
+  val nonSensicalStartTag: String = "<nonsensical>"
+  val nonSensicalEndTag: String = "</nonsensical>"
 
   implicit class MessageContext(val c: Context) extends AnyVal {
     def shouldExplain(cont: MessageContainer): Boolean = {
@@ -68,8 +68,8 @@ class MessageContainer(
    *  they look weird and are normally follow-up errors to something that was
    *  diagnosed before.
    */
-  def isNonSensical = { message; myIsNonSensical }
+  def isNonSensical: Boolean = { message; myIsNonSensical }
 
-  override def toString = s"$getClass at $pos: ${message}"
-  override def getMessage() = message
+  override def toString: String = s"$getClass at $pos: ${message}"
+  override def getMessage(): String = message
 }
diff --git a/compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala b/compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala
index 10ac5e7356ea..59dc71e76516 100644
--- a/compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala
+++ b/compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala
@@ -56,28 +56,28 @@ object messages {
     msgFn: => Message,
     pos: SourcePosition
   ) extends ConditionalWarning(msgFn, pos) {
-    def enablingOption(implicit ctx: Context) = ctx.settings.feature
+    def enablingOption(implicit ctx: Context): Setting[Boolean] = ctx.settings.feature
   }
 
   class UncheckedWarning(
     msgFn: => Message,
     pos: SourcePosition
   ) extends ConditionalWarning(msgFn, pos) {
-    def enablingOption(implicit ctx: Context) = ctx.settings.unchecked
+    def enablingOption(implicit ctx: Context): Setting[Boolean] = ctx.settings.unchecked
   }
 
   class DeprecationWarning(
     msgFn: => Message,
     pos: SourcePosition
   ) extends ConditionalWarning(msgFn, pos) {
-    def enablingOption(implicit ctx: Context) = ctx.settings.deprecation
+    def enablingOption(implicit ctx: Context): Setting[Boolean] = ctx.settings.deprecation
   }
 
   class MigrationWarning(
     msgFn: => Message,
     pos: SourcePosition
   ) extends ConditionalWarning(msgFn, pos) {
-    def enablingOption(implicit ctx: Context) = ctx.settings.migration
+    def enablingOption(implicit ctx: Context): Setting[Boolean] = ctx.settings.migration
   }
 
   /**  Messages
@@ -97,7 +97,7 @@ object messages {
   import ast.tpd
 
   /** Helper methods for messages */
-  def implicitClassRestrictionsText(implicit ctx: Context) =
+  def implicitClassRestrictionsText(implicit ctx: Context): String =
     hl"""|${NoColor("For a full list of restrictions on implicit classes visit")}
          |${Blue("http://docs.scala-lang.org/overviews/core/implicit-classes.html")}"""
 
@@ -105,7 +105,7 @@ object messages {
   // Syntax Errors ---------------------------------------------------------- //
   abstract class EmptyCatchOrFinallyBlock(tryBody: untpd.Tree, errNo: ErrorMessageID)(implicit ctx: Context)
   extends Message(EmptyCatchOrFinallyBlockID) {
-    val explanation = {
+    val explanation: String = {
       val tryString = tryBody match {
         case Block(Nil, untpd.EmptyTree) => "{}"
         case _ => tryBody.show
@@ -141,26 +141,26 @@ object messages {
 
   case class EmptyCatchBlock(tryBody: untpd.Tree)(implicit ctx: Context)
   extends EmptyCatchOrFinallyBlock(tryBody, EmptyCatchBlockID) {
-    val kind = "Syntax"
-    val msg =
+    val kind: String = "Syntax"
+    val msg: String =
       hl"""|The ${"catch"} block does not contain a valid expression, try
            |adding a case like - `${"case e: Exception =>"}` to the block"""
   }
 
   case class EmptyCatchAndFinallyBlock(tryBody: untpd.Tree)(implicit ctx: Context)
   extends EmptyCatchOrFinallyBlock(tryBody, EmptyCatchAndFinallyBlockID) {
-    val kind = "Syntax"
-    val msg =
+    val kind: String = "Syntax"
+    val msg: String =
       hl"""|A ${"try"} without ${"catch"} or ${"finally"} is equivalent to putting
            |its body in a block; no exceptions are handled."""
   }
 
   case class DeprecatedWithOperator()(implicit ctx: Context)
   extends Message(DeprecatedWithOperatorID) {
-    val kind = "Syntax"
-    val msg =
+    val kind: String = "Syntax"
+    val msg: String =
       hl"""${"with"} as a type operator has been deprecated; use `&' instead"""
-    val explanation =
+    val explanation: String =
       hl"""|Dotty introduces intersection types - `&' types. These replace the
            |use of the ${"with"} keyword. There are a few differences in
            |semantics between intersection types and using `${"with"}'."""
@@ -168,11 +168,11 @@ object messages {
 
   case class CaseClassMissingParamList(cdef: untpd.TypeDef)(implicit ctx: Context)
   extends Message(CaseClassMissingParamListID) {
-    val kind = "Syntax"
-    val msg =
+    val kind: String = "Syntax"
+    val msg: String =
       hl"""|A ${"case class"} must have at least one parameter list"""
 
-    val explanation =
+    val explanation: String =
       hl"""|${cdef.name} must have at least one parameter list, if you would rather
            |have a singleton representation of ${cdef.name}, use a "${"case object"}".
            |Or, add an explicit `()' as a parameter list to ${cdef.name}."""
@@ -184,9 +184,9 @@ object messages {
                                                pt: Type)
                                               (implicit ctx: Context)
   extends Message(AnonymousFunctionMissingParamTypeID) {
-    val kind = "Syntax"
+    val kind: String = "Syntax"
 
-    val msg = {
+    val msg: String = {
       val ofFun =
         if (MethodType.syntheticParamNames(args.length + 1) contains param.name)
           i" of expanded function:\n$tree"
@@ -200,7 +200,7 @@ object messages {
          |Missing type for parameter ${param.name}$ofFun"""
     }
 
-    val explanation =
+    val explanation: String =
       hl"""|Anonymous functions must define a type. For example, if you define a function like this one:
            |
            |${"val f = { case x: Int => x + 1 }"}
@@ -212,10 +212,10 @@ object messages {
 
   case class WildcardOnTypeArgumentNotAllowedOnNew()(implicit ctx: Context)
   extends Message(WildcardOnTypeArgumentNotAllowedOnNewID) {
-    val kind = "syntax"
-    val msg = "type argument must be fully defined"
+    val kind: String = "syntax"
+    val msg: String = "type argument must be fully defined"
 
-    val code1 =
+    val code1: String =
       """
         |object TyperDemo {
         |  class Team[A]
@@ -223,7 +223,7 @@ object messages {
         |}
       """.stripMargin
 
-    val code2 =
+    val code2: String =
       """
         |object TyperDemo {
         |  class Team[A]
@@ -231,7 +231,7 @@ object messages {
         |}
       """.stripMargin
 
-    val explanation =
+    val explanation: String =
       hl"""|Wildcard on arguments is not allowed when declaring a new type.
            |
            |Given the following example:
@@ -247,10 +247,10 @@ object messages {
   // Type Errors ------------------------------------------------------------ //
   case class DuplicateBind(bind: untpd.Bind, tree: untpd.CaseDef)(implicit ctx: Context)
   extends Message(DuplicateBindID) {
-    val kind = "Naming"
-    val msg = em"duplicate pattern variable: `${bind.name}`"
+    val kind: String = "Naming"
+    val msg: String = em"duplicate pattern variable: `${bind.name}`"
 
-    val explanation = {
+    val explanation: String = {
       val pat = tree.pat.show
       val guard = tree.guard match {
         case untpd.EmptyTree => ""
@@ -274,10 +274,10 @@ object messages {
 
   case class MissingIdent(tree: untpd.Ident, treeKind: String, name: String)(implicit ctx: Context)
   extends Message(MissingIdentID) {
-    val kind = "Unbound Identifier"
-    val msg = em"not found: $treeKind$name"
+    val kind: String = "Unbound Identifier"
+    val msg: String = em"not found: $treeKind$name"
 
-    val explanation = {
+    val explanation: String = {
       hl"""|The identifier for `$treeKind$name` is not bound, that is,
            |no declaration for this identifier can be found.
            |That can happen for instance if $name or its declaration has either been
@@ -287,8 +287,8 @@ object messages {
 
   case class TypeMismatch(found: Type, expected: Type, whyNoMatch: String = "", implicitFailure: String = "")(implicit ctx: Context)
   extends Message(TypeMismatchID) {
-    val kind = "Type Mismatch"
-    val msg = {
+    val kind: String = "Type Mismatch"
+    val msg: String = {
       val (where, printCtx) = Formatting.disambiguateTypes(found, expected)
       val (fnd, exp) = Formatting.typeDiff(found, expected)(printCtx)
       s"""|found:    $fnd
@@ -297,16 +297,16 @@ object messages {
           |$where""".stripMargin + whyNoMatch + implicitFailure
     }
 
-    val explanation = ""
+    val explanation: String = ""
   }
 
   case class NotAMember(site: Type, name: Name, selected: String)(implicit ctx: Context)
   extends Message(NotAMemberID) {
-    val kind = "Member Not Found"
+    val kind: String = "Member Not Found"
 
     //println(i"site = $site, decls = ${site.decls}, source = ${site.widen.typeSymbol.sourceFile}") //DEBUG
 
-    val msg = {
+    val msg: String = {
       import core.Flags._
       val maxDist = 3
       val decls = site.decls.toList.flatMap { sym =>
@@ -363,15 +363,15 @@ object messages {
       ex"$selected `$name` is not a member of ${site.widen}$closeMember"
     }
 
-    val explanation = ""
+    val explanation: String = ""
   }
 
   case class EarlyDefinitionsNotSupported()(implicit ctx: Context)
   extends Message(EarlyDefinitionsNotSupportedID) {
-    val kind = "Syntax"
-    val msg = "early definitions are not supported; use trait parameters instead"
+    val kind: String = "Syntax"
+    val msg: String = "early definitions are not supported; use trait parameters instead"
 
-    val explanation = {
+    val explanation: String = {
       val code1 =
         """|trait Logging {
            |  val f: File
@@ -414,10 +414,10 @@ object messages {
 
   case class TopLevelImplicitClass(cdef: untpd.TypeDef)(implicit ctx: Context)
   extends Message(TopLevelImplicitClassID) {
-    val kind = "Syntax"
-    val msg = hl"""An ${"implicit class"} may not be top-level"""
+    val kind: String = "Syntax"
+    val msg: String = hl"""An ${"implicit class"} may not be top-level"""
 
-    val explanation = {
+    val explanation: String = {
       val TypeDef(name, impl @ Template(constr0, parents, self, _)) = cdef
       val exampleArgs =
         if(constr0.vparamss.isEmpty) "..."
@@ -445,10 +445,10 @@ object messages {
 
   case class ImplicitCaseClass(cdef: untpd.TypeDef)(implicit ctx: Context)
   extends Message(ImplicitCaseClassID) {
-    val kind = "Syntax"
-    val msg = hl"""A ${"case class"} may not be defined as ${"implicit"}"""
+    val kind: String = "Syntax"
+    val msg: String = hl"""A ${"case class"} may not be defined as ${"implicit"}"""
 
-    val explanation =
+    val explanation: String =
       hl"""|implicit classes may not be case classes. Instead use a plain class:
            |
            |implicit class ${cdef.name}...
@@ -458,9 +458,9 @@ object messages {
 
   case class ImplicitClassPrimaryConstructorArity()(implicit ctx: Context)
   extends Message(ImplicitClassPrimaryConstructorArityID){
-    val kind = "Syntax"
-    val msg = "Implicit classes must accept exactly one primary constructor parameter"
-    val explanation = {
+    val kind: String = "Syntax"
+    val msg: String = "Implicit classes must accept exactly one primary constructor parameter"
+    val explanation: String = {
       val example = "implicit class RichDate(date: java.util.Date)"
       hl"""Implicit classes may only take one non-implicit argument in their constructor. For example:
           |
@@ -474,10 +474,10 @@ object messages {
 
   case class ObjectMayNotHaveSelfType(mdef: untpd.ModuleDef)(implicit ctx: Context)
   extends Message(ObjectMayNotHaveSelfTypeID) {
-    val kind = "Syntax"
-    val msg = hl"""${"object"}s must not have a self ${"type"}"""
+    val kind: String = "Syntax"
+    val msg: String = hl"""${"object"}s must not have a self ${"type"}"""
 
-    val explanation = {
+    val explanation: String = {
       val untpd.ModuleDef(name, tmpl) = mdef
       val ValDef(_, selfTpt, _) = tmpl.self
       hl"""|${"object"}s must not have a self ${"type"}:
@@ -492,10 +492,10 @@ object messages {
 
   case class RepeatedModifier(modifier: String)(implicit ctx:Context)
   extends Message(RepeatedModifierID) {
-    val kind = "Syntax"
-    val msg = hl"""repeated modifier $modifier"""
+    val kind: String = "Syntax"
+    val msg: String = hl"""repeated modifier $modifier"""
 
-    val explanation = {
+    val explanation: String = {
       val code1 = hl"""private private val Origin = Point(0, 0)"""
       val code2 = hl"""private final val Origin = Point(0, 0)"""
       hl"""This happens when you accidentally specify the same modifier twice.
@@ -514,9 +514,9 @@ object messages {
 
   case class InterpolatedStringError()(implicit ctx:Context)
   extends Message(InterpolatedStringErrorID) {
-    val kind = "Syntax"
-    val msg = "error in interpolated string: identifier or block expected"
-    val explanation = {
+    val kind: String = "Syntax"
+    val msg: String = "error in interpolated string: identifier or block expected"
+    val explanation: String = {
       val code1 = "s\"$new Point(0, 0)\""
       val code2 = "s\"${new Point(0, 0)}\""
       hl"""|This usually happens when you forget to place your expressions inside curly braces.
@@ -532,9 +532,9 @@ object messages {
 
   case class UnboundPlaceholderParameter()(implicit ctx:Context)
   extends Message(UnboundPlaceholderParameterID) {
-    val kind = "Syntax"
-    val msg = "unbound placeholder parameter; incorrect use of `_`"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = "unbound placeholder parameter; incorrect use of `_`"
+    val explanation: String =
       hl"""|The `_` placeholder syntax was used where it could not be bound.
            |Consider explicitly writing the variable binding.
            |
@@ -568,9 +568,9 @@ object messages {
 
   case class IllegalStartSimpleExpr(illegalToken: String)(implicit ctx: Context)
   extends Message(IllegalStartSimpleExprID) {
-    val kind = "Syntax"
-    val msg = "illegal start of simple expression"
-    val explanation = {
+    val kind: String = "Syntax"
+    val msg: String = "illegal start of simple expression"
+    val explanation: String = {
       hl"""|An expression yields a value. In the case of the simple expression, this error
            |commonly occurs when there's a missing parenthesis or brace. The reason being
            |that a simple expression is one of the following:
@@ -587,9 +587,9 @@ object messages {
 
   case class MissingReturnType()(implicit ctx:Context)
   extends Message(MissingReturnTypeID) {
-    val kind = "Syntax"
-    val msg = "missing return type"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = "missing return type"
+    val explanation: String =
       hl"""|An abstract declaration must have a return type. For example:
            |
            |trait Shape {
@@ -599,9 +599,9 @@ object messages {
 
   case class MissingReturnTypeWithReturnStatement(method: Symbol)(implicit ctx: Context)
   extends Message(MissingReturnTypeWithReturnStatementID) {
-    val kind = "Syntax"
-    val msg = hl"$method has a return statement; it needs a result type"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = hl"$method has a return statement; it needs a result type"
+    val explanation: String =
       hl"""|If a method contains a ${"return"} statement, it must have an
            |explicit return type. For example:
            |
@@ -610,10 +610,10 @@ object messages {
 
   case class YieldOrDoExpectedInForComprehension()(implicit ctx: Context)
   extends Message(YieldOrDoExpectedInForComprehensionID) {
-    val kind = "Syntax"
-    val msg = hl"${"yield"} or ${"do"} expected"
+    val kind: String = "Syntax"
+    val msg: String = hl"${"yield"} or ${"do"} expected"
 
-    val explanation =
+    val explanation: String =
       hl"""|When the enumerators in a for comprehension are not placed in parentheses or
            |braces, a ${"do"} or ${"yield"} statement is required after the enumerators
            |section of the comprehension.
@@ -643,10 +643,10 @@ object messages {
 
   case class ProperDefinitionNotFound()(implicit ctx: Context)
   extends Message(ProperDefinitionNotFoundID) {
-    val kind = "Definition Not Found"
-    val msg = hl"""Proper definition was not found in ${"@usecase"}"""
+    val kind: String = "Definition Not Found"
+    val msg: String = hl"""Proper definition was not found in ${"@usecase"}"""
 
-    val explanation = {
+    val explanation: String = {
       val noUsecase =
         "def map[B, That](f: A => B)(implicit bf: CanBuildFrom[List[A], B, That]): That"
 
@@ -682,10 +682,10 @@ object messages {
 
   case class ByNameParameterNotSupported(tpe: untpd.TypTree)(implicit ctx: Context)
   extends Message(ByNameParameterNotSupportedID) {
-    val kind = "Syntax"
-    val msg = hl"By-name parameter type ${tpe} not allowed here."
+    val kind: String = "Syntax"
+    val msg: String = hl"By-name parameter type ${tpe} not allowed here."
 
-    val explanation =
+    val explanation: String =
       hl"""|By-name parameters act like functions that are only evaluated when referenced,
            |allowing for lazy evaluation of a parameter.
            |
@@ -706,7 +706,7 @@ object messages {
 
   case class WrongNumberOfTypeArgs(fntpe: Type, expectedArgs: List[ParamInfo], actual: List[untpd.Tree])(implicit ctx: Context)
   extends Message(WrongNumberOfTypeArgsID) {
-    val kind = "Syntax"
+    val kind: String = "Syntax"
 
     private val expectedCount = expectedArgs.length
     private val actualCount = actual.length
@@ -729,12 +729,12 @@ object messages {
         case NonFatal(ex) => fntpe.show
       }
 
-    val msg =
+    val msg: String =
       hl"""|${NoColor(msgPrefix)} type arguments for $prettyName$expectedArgString
            |expected: $expectedArgString
            |actual:   ${NoColor(actualArgString)}""".stripMargin
 
-    val explanation = {
+    val explanation: String = {
       val tooManyTypeParams =
         """|val tuple2: (Int, String) = (1, "one")
            |val list: List[(Int, String)] = List(tuple2)""".stripMargin
@@ -756,9 +756,9 @@ object messages {
 
   case class IllegalVariableInPatternAlternative()(implicit ctx: Context)
   extends Message(IllegalVariableInPatternAlternativeID) {
-    val kind = "Syntax"
-    val msg = "Variables are not allowed in alternative patterns"
-    val explanation = {
+    val kind: String = "Syntax"
+    val msg: String = "Variables are not allowed in alternative patterns"
+    val explanation: String = {
       val varInAlternative =
         """|def g(pair: (Int,Int)): Int = pair match {
            |  case (1, n) | (n, 1) => n
@@ -785,9 +785,9 @@ object messages {
 
   case class IdentifierExpected(identifier: String)(implicit ctx: Context)
   extends Message(IdentifierExpectedID) {
-    val kind = "Syntax"
-    val msg = "identifier expected"
-    val explanation = {
+    val kind: String = "Syntax"
+    val msg: String = "identifier expected"
+    val explanation: String = {
       val wrongIdentifier = s"def foo: $identifier = {...}"
       val validIdentifier = s"def foo = {...}"
       hl"""|An identifier expected, but `$identifier` found. This could be because
@@ -806,9 +806,9 @@ object messages {
 
   case class AuxConstructorNeedsNonImplicitParameter()(implicit ctx:Context)
   extends Message(AuxConstructorNeedsNonImplicitParameterID) {
-    val kind = "Syntax"
-    val msg = "auxiliary constructor needs non-implicit parameter list"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = "auxiliary constructor needs non-implicit parameter list"
+    val explanation: String =
       hl"""|Only the primary constructor is allowed an ${"implicit"} parameter list;
            |auxiliary constructors need non-implicit parameter lists. When a primary
            |constructor has an implicit argslist, auxiliary constructors that call the
@@ -822,9 +822,9 @@ object messages {
 
   case class IncorrectRepeatedParameterSyntax()(implicit ctx: Context)
   extends Message(IncorrectRepeatedParameterSyntaxID) {
-    val kind = "Syntax"
-    val msg = "'*' expected"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = "'*' expected"
+    val explanation: String =
       hl"""|Expected * in '_*' operator.
            |
            |The '_*' operator can be used to supply a sequence-based argument
@@ -849,9 +849,9 @@ object messages {
 
   case class IllegalLiteral()(implicit ctx: Context)
   extends Message(IllegalLiteralID) {
-    val kind = "Syntax"
-    val msg = "illegal literal"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = "illegal literal"
+    val explanation: String =
       hl"""|Available literals can be divided into several groups:
            | - Integer literals: 0, 21, 0xFFFFFFFF, -42L
            | - Floating Point Literals: 0.0, 1e30f, 3.14159f, 1.0e-100, .1
@@ -864,14 +864,14 @@ object messages {
 
   case class PatternMatchExhaustivity(uncovered: String)(implicit ctx: Context)
   extends Message(PatternMatchExhaustivityID) {
-    val kind = "Pattern Match Exhaustivity"
-    val msg =
+    val kind: String = "Pattern Match Exhaustivity"
+    val msg: String =
       hl"""|match may not be exhaustive.
            |
            |It would fail on pattern case: $uncovered"""
 
 
-    val explanation =
+    val explanation: String =
       hl"""|There are several ways to make the match exhaustive:
            | - Add missing cases as shown in the warning
            | - If an extractor always return 'Some(...)', write 'Some[X]' for its return type
@@ -881,9 +881,9 @@ object messages {
 
   case class UncheckedTypePattern(msg: String)(implicit ctx: Context)
     extends Message(UncheckedTypePatternID) {
-    val kind = "Pattern Match Exhaustivity"
+    val kind: String = "Pattern Match Exhaustivity"
 
-    val explanation =
+    val explanation: String =
       hl"""|Type arguments and type refinements are erased during compile time, thus it's
            |impossible to check them at run-time.
            |
@@ -893,23 +893,23 @@ object messages {
 
   case class MatchCaseUnreachable()(implicit ctx: Context)
   extends Message(MatchCaseUnreachableID) {
-    val kind = "Match case Unreachable"
-    val msg = "unreachable case"
-    val explanation = ""
+    val kind: String = "Match case Unreachable"
+    val msg: String = "unreachable case"
+    val explanation: String = ""
   }
 
   case class MatchCaseOnlyNullWarning()(implicit ctx: Context)
   extends Message(MatchCaseOnlyNullWarningID) {
-    val kind = "Only null matched"
-    val msg = s"Only ${hl"null"} is matched. Consider using `case null =>` instead."
-    val explanation = ""
+    val kind: String = "Only null matched"
+    val msg: String = s"Only ${hl"null"} is matched. Consider using `case null =>` instead."
+    val explanation: String = ""
   }
 
   case class SeqWildcardPatternPos()(implicit ctx: Context)
   extends Message(SeqWildcardPatternPosID) {
-    val kind = "Syntax"
-    val msg = "`_*' can be used only for last argument"
-    val explanation = {
+    val kind: String = "Syntax"
+    val msg: String = "`_*' can be used only for last argument"
+    val explanation: String = {
       val code =
         """def sumOfTheFirstTwo(list: List[Int]): Int = list match {
           |  case List(first, second, x:_*) => first + second
@@ -931,9 +931,9 @@ object messages {
 
   case class IllegalStartOfSimplePattern()(implicit ctx: Context)
   extends Message(IllegalStartOfSimplePatternID) {
-    val kind = "Syntax"
-    val msg = "illegal start of simple pattern"
-    val explanation = {
+    val kind: String = "Syntax"
+    val msg: String = "illegal start of simple pattern"
+    val explanation: String = {
       val sipCode =
         """def f(x: Int, y: Int) = x match {
           |  case `y` => ...
@@ -1011,18 +1011,18 @@ object messages {
 
   case class PkgDuplicateSymbol(existing: Symbol)(implicit ctx: Context)
   extends Message(PkgDuplicateSymbolID) {
-    val kind = "Duplicate Symbol"
-    val msg = hl"trying to define package with same name as `$existing`"
-    val explanation = ""
+    val kind: String = "Duplicate Symbol"
+    val msg: String = hl"trying to define package with same name as `$existing`"
+    val explanation: String = ""
   }
 
   case class ExistentialTypesNoLongerSupported()(implicit ctx: Context)
   extends Message(ExistentialTypesNoLongerSupportedID) {
-    val kind = "Syntax"
-    val msg =
+    val kind: String = "Syntax"
+    val msg: String =
       hl"""|Existential types are no longer supported -
            |use a wildcard or dependent type instead"""
-    val explanation =
+    val explanation: String =
       hl"""|The use of existential types is no longer supported.
            |
            |You should use a wildcard or dependent type instead.
@@ -1041,9 +1041,9 @@ object messages {
 
   case class UnboundWildcardType()(implicit ctx: Context)
   extends Message(UnboundWildcardTypeID) {
-    val kind = "Syntax"
-    val msg = "Unbound wildcard type"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = "Unbound wildcard type"
+    val explanation: String =
       hl"""|The wildcard type syntax (`_`) was used where it could not be bound.
            |Replace `_` with a non-wildcard type. If the type doesn't matter,
            |try replacing `_` with ${"Any"}.
@@ -1085,10 +1085,10 @@ object messages {
   }
 
   case class DanglingThisInPath()(implicit ctx: Context) extends Message(DanglingThisInPathID) {
-    val kind = "Syntax"
-    val msg = hl"""Expected an additional member selection after the keyword ${"this"}"""
+    val kind: String = "Syntax"
+    val msg: String = hl"""Expected an additional member selection after the keyword ${"this"}"""
 
-    val contextCode =
+    val contextCode: String =
       """  trait Outer {
         |    val member: Int
         |    type Member
@@ -1097,15 +1097,15 @@ object messages {
         |    }
         |  }"""
 
-    val importCode =
+    val importCode: String =
       """  import Outer.this.member
         |  //               ^^^^^^^"""
 
-    val typeCode =
+    val typeCode: String =
       """  type T = Outer.this.Member
         |  //                 ^^^^^^^"""
 
-    val explanation =
+    val explanation: String =
       hl"""|Paths of imports and type selections must not end with the keyword ${"this"}.
            |
            |Maybe you forgot to select a member of ${"this"}? As an example, in the
@@ -1122,10 +1122,10 @@ object messages {
 
   case class OverridesNothing(member: Symbol)(implicit ctx: Context)
   extends Message(OverridesNothingID) {
-    val kind = "Reference"
-    val msg = hl"""${member} overrides nothing"""
+    val kind: String = "Reference"
+    val msg: String = hl"""${member} overrides nothing"""
 
-    val explanation =
+    val explanation: String =
       hl"""|There must be a field or method with the name `${member.name}` in a super
            |class of `${member.owner}` to override it. Did you misspell it?
            |Are you extending the right classes?
@@ -1134,12 +1134,12 @@ object messages {
 
   case class OverridesNothingButNameExists(member: Symbol, existing: List[Denotations.SingleDenotation])(implicit ctx: Context)
   extends Message(OverridesNothingButNameExistsID) {
-    val kind = "Reference"
-    val msg = hl"""${member} has a different signature than the overridden declaration"""
+    val kind: String = "Reference"
+    val msg: String = hl"""${member} has a different signature than the overridden declaration"""
 
-    val existingDecl = existing.map(_.showDcl).mkString("  \n")
+    val existingDecl: String = existing.map(_.showDcl).mkString("  \n")
 
-    val explanation =
+    val explanation: String =
       hl"""|There must be a non-final field or method with the name `${member.name}` and the
            |same parameter list in a super class of `${member.owner}` to override it.
            |
@@ -1153,10 +1153,10 @@ object messages {
 
   case class ForwardReferenceExtendsOverDefinition(value: Symbol, definition: Symbol)(implicit ctx: Context)
   extends Message(ForwardReferenceExtendsOverDefinitionID) {
-    val kind = "Reference"
-    val msg = hl"`${definition.name}` is a forward reference extending over the definition of `${value.name}`"
+    val kind: String = "Reference"
+    val msg: String = hl"`${definition.name}` is a forward reference extending over the definition of `${value.name}`"
 
-    val explanation =
+    val explanation: String =
       hl"""|`${definition.name}` is used before you define it, and the definition of `${value.name}`
            |appears between that use and the definition of `${definition.name}`.
            |
@@ -1172,7 +1172,7 @@ object messages {
 
   case class ExpectedTokenButFound(expected: Token, found: Token)(implicit ctx: Context)
   extends Message(ExpectedTokenButFoundID) {
-    val kind = "Syntax"
+    val kind: String = "Syntax"
 
     private val expectedText =
       if (Tokens.isIdentifier(expected)) "an identifier"
@@ -1180,7 +1180,7 @@ object messages {
 
     private val foundText = Tokens.showToken(found)
 
-    val msg = hl"""${expectedText} expected, but ${foundText} found"""
+    val msg: String = hl"""${expectedText} expected, but ${foundText} found"""
 
     private val ifKeyword =
       if (Tokens.isIdentifier(expected) && Tokens.isKeyword(found))
@@ -1188,16 +1188,16 @@ object messages {
            |If you necessarily want to use $foundText as identifier, you may put it in backticks.""".stripMargin
       else
         ""
-    val explanation = s"$ifKeyword"
+    val explanation: String = s"$ifKeyword"
   }
 
   case class MixedLeftAndRightAssociativeOps(op1: Name, op2: Name, op2LeftAssoc: Boolean)(implicit ctx: Context)
   extends Message(MixedLeftAndRightAssociativeOpsID) {
-    val kind = "Syntax"
-    val op1Asso = if (op2LeftAssoc) "which is right-associative" else "which is left-associative"
-    val op2Asso = if (op2LeftAssoc) "which is left-associative" else "which is right-associative"
-    val msg = s"`${op1}` (${op1Asso}) and `${op2}` ($op2Asso) have same precedence and may not be mixed"
-    val explanation =
+    val kind: String = "Syntax"
+    val op1Asso: String = if (op2LeftAssoc) "which is right-associative" else "which is left-associative"
+    val op2Asso: String = if (op2LeftAssoc) "which is left-associative" else "which is right-associative"
+    val msg: String = s"`${op1}` (${op1Asso}) and `${op2}` ($op2Asso) have same precedence and may not be mixed"
+    val explanation: String =
       s"""|The operators ${op1} and ${op2} are used as infix operators in the same expression,
           |but they bind to different sides:
           |${op1} is applied to the operand to its ${if (op2LeftAssoc) "right" else "left"}
@@ -1227,10 +1227,10 @@ object messages {
 
   case class CantInstantiateAbstractClassOrTrait(cls: Symbol, isTrait: Boolean)(implicit ctx: Context)
   extends Message(CantInstantiateAbstractClassOrTraitID) {
-    val kind = "Usage"
+    val kind: String = "Usage"
     private val traitOrAbstract = if (isTrait) hl"a trait" else hl"abstract"
-    val msg = hl"""${cls.name} is ${traitOrAbstract}; it cannot be instantiated"""
-    val explanation =
+    val msg: String = hl"""${cls.name} is ${traitOrAbstract}; it cannot be instantiated"""
+    val explanation: String =
       hl"""|Abstract classes and traits need to be extended by a concrete class or object
            |to make their functionality accessible.
            |
@@ -1246,9 +1246,9 @@ object messages {
 
   case class OverloadedOrRecursiveMethodNeedsResultType(cycleSym: Symbol)(implicit ctx: Context)
   extends Message(OverloadedOrRecursiveMethodNeedsResultTypeID) {
-    val kind = "Cyclic"
-    val msg = hl"""overloaded or recursive $cycleSym needs return type"""
-    val explanation =
+    val kind: String = "Cyclic"
+    val msg: String = hl"""overloaded or recursive $cycleSym needs return type"""
+    val explanation: String =
       hl"""Case 1: $cycleSym is overloaded
           |If there are multiple methods named `$cycleSym` and at least one definition of
           |it calls another, you need to specify the calling method's return type.
@@ -1261,18 +1261,18 @@ object messages {
 
   case class RecursiveValueNeedsResultType(cycleSym: Symbol)(implicit ctx: Context)
   extends Message(RecursiveValueNeedsResultTypeID) {
-    val kind = "Cyclic"
-    val msg = hl"""recursive $cycleSym needs type"""
-    val explanation =
+    val kind: String = "Cyclic"
+    val msg: String = hl"""recursive $cycleSym needs type"""
+    val explanation: String =
       hl"""The definition of `$cycleSym` is recursive and you need to specify its type.
           |""".stripMargin
   }
 
   case class CyclicReferenceInvolving(denot: SymDenotation)(implicit ctx: Context)
   extends Message(CyclicReferenceInvolvingID) {
-    val kind = "Cyclic"
-    val msg = hl"""cyclic reference involving $denot"""
-    val explanation =
+    val kind: String = "Cyclic"
+    val msg: String = hl"""cyclic reference involving $denot"""
+    val explanation: String =
       hl"""|$denot is declared as part of a cycle which makes it impossible for the
            |compiler to decide upon ${denot.name}'s type.
            |To avoid this error, try giving `${denot.name}` an explicit type.
@@ -1281,9 +1281,9 @@ object messages {
 
   case class CyclicReferenceInvolvingImplicit(cycleSym: Symbol)(implicit ctx: Context)
   extends Message(CyclicReferenceInvolvingImplicitID) {
-    val kind = "Cyclic"
-    val msg = hl"""cyclic reference involving implicit $cycleSym"""
-    val explanation =
+    val kind: String = "Cyclic"
+    val msg: String = hl"""cyclic reference involving implicit $cycleSym"""
+    val explanation: String =
       hl"""|$cycleSym is declared as part of a cycle which makes it impossible for the
            |compiler to decide upon ${cycleSym.name}'s type.
            |This might happen when the right hand-side of $cycleSym's definition involves an implicit search.
@@ -1291,15 +1291,15 @@ object messages {
            |""".stripMargin
   }
 
-  case class SuperQualMustBeParent(qual: untpd.Ident, cls: Symbols.ClassSymbol)(implicit ctx: Context)
+  case class SuperQualMustBeParent(qual: untpd.Ident, cls: ClassSymbol)(implicit ctx: Context)
   extends Message(SuperQualMustBeParentID) {
 
-    val msg = hl"""|$qual does not name a parent of $cls"""
-    val kind = "Reference"
+    val msg: String = hl"""|$qual does not name a parent of $cls"""
+    val kind: String = "Reference"
 
     private val parents: Seq[String] = (cls.info.parents map (_.typeSymbol.name.show)).sorted
 
-    val explanation =
+    val explanation: String =
       hl"""|When a qualifier ${"T"} is used in a ${"super"} prefix of the form ${"C.super[T]"},
            |${"T"} must be a parent type of ${"C"}.
            |
@@ -1310,15 +1310,15 @@ object messages {
 
   case class VarArgsParamMustComeLast()(implicit ctx: Context)
   extends Message(IncorrectRepeatedParameterSyntaxID) {
-    val msg = "varargs parameter must come last"
-    val kind = "Syntax"
-    val explanation =
+    val msg: String = "varargs parameter must come last"
+    val kind: String = "Syntax"
+    val explanation: String =
       hl"""|The varargs field must be the last field in the method signature.
            |Attempting to define a field in a method signature after a varargs field is an error.
            |"""
   }
 
-  case class AmbiguousImport(name: Names.Name, newPrec: Int, prevPrec: Int, prevCtx: Context)(implicit ctx: Context)
+  case class AmbiguousImport(name: Name, newPrec: Int, prevPrec: Int, prevCtx: Context)(implicit ctx: Context)
     extends Message(AmbiguousImportID) {
 
     import typer.Typer.BindingPrec
@@ -1341,14 +1341,14 @@ object messages {
     }
 
 
-    val msg =
+    val msg: String =
       i"""|reference to `${hl"$name"}` is ambiguous
           |it is both ${bindingString(newPrec, ctx)}
           |and ${bindingString(prevPrec, prevCtx, " subsequently")}"""
 
-    val kind = "Reference"
+    val kind: String = "Reference"
 
-    val explanation =
+    val explanation: String =
       hl"""|The compiler can't decide which of the possible choices you
            |are referencing with $name.
            |Note:
@@ -1361,16 +1361,16 @@ object messages {
 
   case class MethodDoesNotTakeParameters(tree: tpd.Tree)(implicit ctx: Context)
   extends Message(MethodDoesNotTakeParametersId) {
-    val kind = "Reference"
+    val kind: String = "Reference"
 
-    def methodSymbol = tpd.methPart(tree).symbol
+    def methodSymbol: Symbol = tpd.methPart(tree).symbol
 
-    val msg = {
+    val msg: String = {
       val more = if (tree.isInstanceOf[tpd.Apply]) " more" else ""
       hl"${methodSymbol.showLocated} does not take$more parameters"
     }
 
-    val explanation = {
+    val explanation: String = {
       val isNullary = methodSymbol.info.isInstanceOf[ExprType]
       val addendum =
         if (isNullary) "\nNullary methods may not be called with parenthesis"
@@ -1387,11 +1387,11 @@ object messages {
   extends Message(AmbiguousOverloadID) {
 
     private val all = if (alts.length == 2) "both" else "all"
-    val msg =
+    val msg: String =
       s"""|Ambiguous overload. The ${err.overloadedAltsStr(alts)}
           |$all match ${err.expectedTypeStr(pt)}""".stripMargin
-    val kind = "Reference"
-    val explanation =
+    val kind: String = "Reference"
+    val explanation: String =
       hl"""|There are ${alts.length} methods that could be referenced as the compiler knows too little
            |about the expected type.
            |You may specify the expected type e.g. by
@@ -1400,11 +1400,11 @@ object messages {
            |"""
   }
 
-  case class ReassignmentToVal(name: Names.Name)(implicit ctx: Context)
+  case class ReassignmentToVal(name: Name)(implicit ctx: Context)
     extends Message(ReassignmentToValID) {
-    val kind = "Reference"
-    val msg = hl"""reassignment to val `$name`"""
-    val explanation =
+    val kind: String = "Reference"
+    val msg: String = hl"""reassignment to val `$name`"""
+    val explanation: String =
       hl"""|You can not assign a new value to `$name` as values can't be changed.
            |Keep in mind that every statement has a value, so you may e.g. use
            |  ${"val"} $name ${"= if (condition) 2 else 5"}
@@ -1414,16 +1414,16 @@ object messages {
            |""".stripMargin
   }
 
-  case class TypeDoesNotTakeParameters(tpe: Types.Type, params: List[Trees.Tree[Trees.Untyped]])(implicit ctx: Context)
+  case class TypeDoesNotTakeParameters(tpe: Type, params: List[Trees.Tree[Trees.Untyped]])(implicit ctx: Context)
     extends Message(TypeDoesNotTakeParametersID) {
-    val kind = "Reference"
-    val msg = hl"$tpe does not take type parameters"
+    val kind: String = "Reference"
+    val msg: String = hl"$tpe does not take type parameters"
 
     private val ps =
       if (params.size == 1) s"a type parameter ${params.head}"
       else s"type parameters ${params.map(_.show).mkString(", ")}"
 
-    val explanation =
+    val explanation: String =
       i"""You specified ${NoColor(ps)} for ${hl"$tpe"}, which is not
          |declared to take any.
          |"""
@@ -1431,19 +1431,19 @@ object messages {
 
   case class ParameterizedTypeLacksArguments(psym: Symbol)(implicit ctx: Context)
     extends Message(ParameterizedTypeLacksArgumentsID) {
-    val msg = hl"parameterized $psym lacks argument list"
-    val kind = "Reference"
-    val explanation =
+    val msg: String = hl"parameterized $psym lacks argument list"
+    val kind: String = "Reference"
+    val explanation: String =
       hl"""The $psym is declared with non-implicit parameters, you may not leave
           |out the parameter list when extending it.
           |"""
   }
 
-  case class VarValParametersMayNotBeCallByName(name: Names.TermName, mutable: Boolean)(implicit ctx: Context)
+  case class VarValParametersMayNotBeCallByName(name: TermName, mutable: Boolean)(implicit ctx: Context)
     extends Message(VarValParametersMayNotBeCallByNameID) {
-    val msg = s"${if (mutable) "`var'" else "`val'"} parameters may not be call-by-name"
-    val kind = "Syntax"
-    val explanation =
+    val msg: String = s"${if (mutable) "`var'" else "`val'"} parameters may not be call-by-name"
+    val kind: String = "Syntax"
+    val explanation: String =
       hl"""${"var"} and ${"val"} parameters of classes and traits may no be call-by-name. In case you
           |want the parameter to be evaluated on demand, consider making it just a parameter
           |and a ${"def"} in the class such as
@@ -1455,29 +1455,29 @@ object messages {
 
   case class MissingTypeParameterFor(tpe: Type)(implicit ctx: Context)
     extends Message(MissingTypeParameterForID) {
-    val msg =
+    val msg: String =
       if (tpe.derivesFrom(defn.AnyKindClass)) hl"${tpe} cannot be used as a value type"
       else hl"missing type parameter for ${tpe}"
-    val kind = "Syntax"
-    val explanation = ""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class DoesNotConformToBound(tpe: Type, which: String, bound: Type)(
     err: typer.ErrorReporting.Errors)(implicit ctx: Context)
     extends Message(DoesNotConformToBoundID) {
-    val msg = hl"Type argument ${tpe} does not conform to $which bound $bound ${err.whyNoMatchStr(tpe, bound)}"
-    val kind = "Type Mismatch"
-    val explanation = ""
+    val msg: String = hl"Type argument ${tpe} does not conform to $which bound $bound ${err.whyNoMatchStr(tpe, bound)}"
+    val kind: String = "Type Mismatch"
+    val explanation: String = ""
   }
 
   case class DoesNotConformToSelfType(category: String, selfType: Type, cls: Symbol,
                                       otherSelf: Type, relation: String, other: Symbol)(
     implicit ctx: Context)
     extends Message(DoesNotConformToSelfTypeID) {
-    val msg = hl"""$category: self type $selfType of $cls does not conform to self type $otherSelf
+    val msg: String = hl"""$category: self type $selfType of $cls does not conform to self type $otherSelf
                   |of $relation $other"""
-    val kind = "Type Mismatch"
-    val explanation =
+    val kind: String = "Type Mismatch"
+    val explanation: String =
       hl"""You mixed in $other which requires self type $otherSelf, but $cls has self type
           |$selfType and does not inherit from $otherSelf.
           |
@@ -1489,9 +1489,9 @@ object messages {
   case class DoesNotConformToSelfTypeCantBeInstantiated(tp: Type, selfType: Type)(
     implicit ctx: Context)
     extends Message(DoesNotConformToSelfTypeCantBeInstantiatedID) {
-    val msg = hl"""$tp does not conform to its self type $selfType; cannot be instantiated"""
-    val kind = "Type Mismatch"
-    val explanation =
+    val msg: String = hl"""$tp does not conform to its self type $selfType; cannot be instantiated"""
+    val kind: String = "Type Mismatch"
+    val explanation: String =
       hl"""To create an instance of $tp it needs to inherit $selfType in some way.
           |
           |Note: Self types are indicated with the notation
@@ -1502,58 +1502,58 @@ object messages {
   case class AbstractMemberMayNotHaveModifier(sym: Symbol, flag: FlagSet)(
     implicit ctx: Context)
     extends Message(AbstractMemberMayNotHaveModifierID) {
-    val msg = hl"""${"abstract"} $sym may not have `$flag' modifier"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""${"abstract"} $sym may not have `$flag' modifier"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class TopLevelCantBeImplicit(sym: Symbol)(
     implicit ctx: Context)
     extends Message(TopLevelCantBeImplicitID) {
-    val msg = hl"""${"implicit"} modifier cannot be used for top-level definitions"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""${"implicit"} modifier cannot be used for top-level definitions"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class TypesAndTraitsCantBeImplicit(sym: Symbol)(
     implicit ctx: Context)
     extends Message(TypesAndTraitsCantBeImplicitID) {
-    val msg = hl"""${"implicit"} modifier cannot be used for types or traits"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""${"implicit"} modifier cannot be used for types or traits"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class OnlyClassesCanBeAbstract(sym: Symbol)(
     implicit ctx: Context)
     extends Message(OnlyClassesCanBeAbstractID) {
-    val msg = hl"""${"abstract"} modifier can be used only for classes; it should be omitted for abstract members"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""${"abstract"} modifier can be used only for classes; it should be omitted for abstract members"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class AbstractOverrideOnlyInTraits(sym: Symbol)(
     implicit ctx: Context)
     extends Message(AbstractOverrideOnlyInTraitsID) {
-    val msg = hl"""${"abstract override"} modifier only allowed for members of traits"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""${"abstract override"} modifier only allowed for members of traits"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class TraitsMayNotBeFinal(sym: Symbol)(
     implicit ctx: Context)
     extends Message(TraitsMayNotBeFinalID) {
-    val msg = hl"""$sym may not be ${"final"}"""
-    val kind = "Syntax"
-    val explanation =
+    val msg: String = hl"""$sym may not be ${"final"}"""
+    val kind: String = "Syntax"
+    val explanation: String =
       "A trait can never be final since it is abstract and must be extended to be useful."
   }
 
   case class NativeMembersMayNotHaveImplementation(sym: Symbol)(
     implicit ctx: Context)
     extends Message(NativeMembersMayNotHaveImplementationID) {
-    val msg = hl"""${"@native"} members may not have an implementation"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""${"@native"} members may not have an implementation"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class OnlyClassesCanHaveDeclaredButUndefinedMembers(sym: Symbol)(
@@ -1563,16 +1563,16 @@ object messages {
     private val varNote =
       if (sym.is(Mutable)) "Note that variables need to be initialized to be defined."
       else ""
-    val msg = hl"""declaration of $sym not allowed here: only classes can have declared but undefined members"""
-    val kind = "Syntax"
-    val explanation = s"$varNote"
+    val msg: String = hl"""declaration of $sym not allowed here: only classes can have declared but undefined members"""
+    val kind: String = "Syntax"
+    val explanation: String = s"$varNote"
   }
 
   case class CannotExtendAnyVal(sym: Symbol)(implicit ctx: Context)
     extends Message(CannotExtendAnyValID) {
-    val msg = hl"""$sym cannot extend ${"AnyVal"}"""
-    val kind = "Syntax"
-    val explanation =
+    val msg: String = hl"""$sym cannot extend ${"AnyVal"}"""
+    val kind: String = "Syntax"
+    val explanation: String =
       hl"""Only classes (not traits) are allowed to extend ${"AnyVal"}, but traits may extend
           |${"Any"} to become ${Green("\"universal traits\"")} which may only have ${"def"} members.
           |Universal traits can be mixed into classes that extend ${"AnyVal"}.
@@ -1590,9 +1590,9 @@ object messages {
            |""".stripMargin
     }
 
-    val msg = hl"""$sym cannot have the same name as ${cls.showLocated} -- """ + reasonMessage
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""$sym cannot have the same name as ${cls.showLocated} -- """ + reasonMessage
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
   object CannotHaveSameNameAs {
     sealed trait Reason
@@ -1602,103 +1602,103 @@ object messages {
 
   case class ValueClassesMayNotDefineInner(valueClass: Symbol, inner: Symbol)(implicit ctx: Context)
     extends Message(ValueClassesMayNotDefineInnerID) {
-    val msg = hl"""value classes may not define an inner class"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""value classes may not define an inner class"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class ValueClassesMayNotDefineNonParameterField(valueClass: Symbol, field: Symbol)(implicit ctx: Context)
     extends Message(ValueClassesMayNotDefineNonParameterFieldID) {
-    val msg = hl"""value classes may not define non-parameter field"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""value classes may not define non-parameter field"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class ValueClassesMayNotDefineASecondaryConstructor(valueClass: Symbol, constructor: Symbol)(implicit ctx: Context)
     extends Message(ValueClassesMayNotDefineASecondaryConstructorID) {
-    val msg = hl"""value classes may not define a secondary constructor"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""value classes may not define a secondary constructor"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class ValueClassesMayNotContainInitalization(valueClass: Symbol)(implicit ctx: Context)
     extends Message(ValueClassesMayNotContainInitalizationID) {
-    val msg = hl"""value classes may not contain initialization statements"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""value classes may not contain initialization statements"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class ValueClassesMayNotBeAbstract(valueClass: Symbol)(implicit ctx: Context)
     extends Message(ValueClassesMayNotBeAbstractID) {
-    val msg = hl"""value classes may not be ${"abstract"}"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""value classes may not be ${"abstract"}"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class ValueClassesMayNotBeContainted(valueClass: Symbol)(implicit ctx: Context)
     extends Message(ValueClassesMayNotBeContaintedID) {
     private val localOrMember = if (valueClass.owner.isTerm) "local class" else "member of another class"
-    val msg = s"""value classes may not be a $localOrMember"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = s"""value classes may not be a $localOrMember"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class ValueClassesMayNotWrapItself(valueClass: Symbol)(implicit ctx: Context)
     extends Message(ValueClassesMayNotWrapItselfID) {
-    val msg = """a value class may not wrap itself"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = """a value class may not wrap itself"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class ValueClassParameterMayNotBeAVar(valueClass: Symbol, param: Symbol)(implicit ctx: Context)
     extends Message(ValueClassParameterMayNotBeAVarID) {
-    val msg = hl"""a value class parameter may not be a ${"var"}"""
-    val kind = "Syntax"
-    val explanation =
+    val msg: String = hl"""a value class parameter may not be a ${"var"}"""
+    val kind: String = "Syntax"
+    val explanation: String =
       hl"""A value class must have exactly one ${"val"} parameter.
           |"""
   }
 
   case class ValueClassNeedsOneValParam(valueClass: Symbol)(implicit ctx: Context)
     extends Message(ValueClassNeedsExactlyOneValParamID) {
-    val msg = hl"""value class needs one ${"val"} parameter"""
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = hl"""value class needs one ${"val"} parameter"""
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class ValueClassParameterMayNotBeCallByName(valueClass: Symbol, param: Symbol)(implicit ctx: Context)
     extends Message(ValueClassParameterMayNotBeCallByNameID) {
-    val msg = s"value class parameter `${param.name}` may not be call-by-name"
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = s"value class parameter `${param.name}` may not be call-by-name"
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class OnlyCaseClassOrCaseObjectAllowed()(implicit ctx: Context)
     extends Message(OnlyCaseClassOrCaseObjectAllowedID) {
-    val msg = "only `case class` or `case object` allowed"
-    val kind = "Syntax"
-    val explanation = ""
+    val msg: String = "only `case class` or `case object` allowed"
+    val kind: String = "Syntax"
+    val explanation: String = ""
   }
 
   case class ExpectedClassOrObjectDef()(implicit ctx: Context)
     extends Message(ExpectedClassOrObjectDefID) {
-    val kind = "Syntax"
-    val msg = "expected class or object definition"
-    val explanation = ""
+    val kind: String = "Syntax"
+    val msg: String = "expected class or object definition"
+    val explanation: String = ""
   }
 
   case class SuperCallsNotAllowedInlineable(symbol: Symbol)(implicit ctx: Context)
     extends Message(SuperCallsNotAllowedInlineableID) {
-    val kind = "Syntax"
-    val msg = s"super call not allowed in inlineable $symbol"
-    val explanation = "Method inlining prohibits calling superclass methods, as it may lead to confusion about which super is being called."
+    val kind: String = "Syntax"
+    val msg: String = s"super call not allowed in inlineable $symbol"
+    val explanation: String = "Method inlining prohibits calling superclass methods, as it may lead to confusion about which super is being called."
   }
 
   case class ModifiersNotAllowed(flags: FlagSet, printableType: Option[String])(implicit ctx: Context)
     extends Message(ModifiersNotAllowedID) {
-    val kind = "Syntax"
-    val msg = s"modifier(s) `$flags' not allowed for ${printableType.getOrElse("combination")}"
-    val explanation = {
+    val kind: String = "Syntax"
+    val msg: String = s"modifier(s) `$flags' not allowed for ${printableType.getOrElse("combination")}"
+    val explanation: String = {
       val first = "sealed def y: Int = 1"
       val second = "sealed lazy class z"
       hl"""You tried to use a modifier that is inapplicable for the type of item under modification
@@ -1717,32 +1717,32 @@ object messages {
 
   case class WrongNumberOfParameters(expected: Int)(implicit ctx: Context)
     extends Message(WrongNumberOfParametersID) {
-    val kind = "Syntax"
-    val msg = s"wrong number of parameters, expected: $expected"
-    val explanation = ""
+    val kind: String = "Syntax"
+    val msg: String = s"wrong number of parameters, expected: $expected"
+    val explanation: String = ""
   }
 
   case class DuplicatePrivateProtectedQualifier()(implicit ctx: Context)
     extends Message(DuplicatePrivateProtectedQualifierID) {
-    val kind = "Syntax"
-    val msg = "duplicate private/protected qualifier"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = "duplicate private/protected qualifier"
+    val explanation: String =
       hl"It is not allowed to combine `private` and `protected` modifiers even if they are qualified to different scopes"
   }
 
   case class ExpectedStartOfTopLevelDefinition()(implicit ctx: Context)
     extends Message(ExpectedStartOfTopLevelDefinitionID) {
-    val kind = "Syntax"
-    val msg = "expected start of definition"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = "expected start of definition"
+    val explanation: String =
       hl"you have to provide either ${"class"}, ${"trait"}, ${"object"}, or ${"enum"} definitions after qualifiers"
   }
 
   case class NoReturnFromInlineable(owner: Symbol)(implicit ctx: Context)
     extends Message(NoReturnFromInlineableID) {
-    val kind = "Syntax"
-    val msg = hl"no explicit ${"return"} allowed from inlineable $owner"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = hl"no explicit ${"return"} allowed from inlineable $owner"
+    val explanation: String =
       hl"""Methods marked with ${"inline"} modifier may not use ${"return"} statements.
           |Instead, you should rely on the last expression's value being
           |returned from a method.
@@ -1751,9 +1751,9 @@ object messages {
 
   case class ReturnOutsideMethodDefinition(owner: Symbol)(implicit ctx: Context)
     extends Message(ReturnOutsideMethodDefinitionID) {
-    val kind = "Syntax"
-    val msg = hl"${"return"} outside method definition"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = hl"${"return"} outside method definition"
+    val explanation: String =
       hl"""You used ${"return"} in ${owner}.
           |${"return"} is a keyword and may only be used within method declarations.
           |"""
@@ -1761,18 +1761,18 @@ object messages {
 
   case class ExtendFinalClass(clazz:Symbol, finalClazz: Symbol)(implicit ctx: Context)
     extends Message(ExtendFinalClassID) {
-    val kind = "Syntax"
-    val msg = hl"$clazz cannot extend ${"final"} $finalClazz"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = hl"$clazz cannot extend ${"final"} $finalClazz"
+    val explanation: String =
       hl"""A class marked with the ${"final"} keyword cannot be extended"""
   }
 
   case class ExpectedTypeBoundOrEquals(found: Token)(implicit ctx: Context)
     extends Message(ExpectedTypeBoundOrEqualsID) {
-    val kind = "Syntax"
-    val msg = hl"${"="}, ${">:"}, or ${"<:"} expected, but ${Tokens.showToken(found)} found"
+    val kind: String = "Syntax"
+    val msg: String = hl"${"="}, ${">:"}, or ${"<:"} expected, but ${Tokens.showToken(found)} found"
 
-    val explanation =
+    val explanation: String =
       hl"""Type parameters and abstract types may be constrained by a type bound.
            |Such type bounds limit the concrete values of the type variables and possibly
            |reveal more information about the members of such types.
@@ -1787,9 +1787,9 @@ object messages {
 
   case class ClassAndCompanionNameClash(cls: Symbol, other: Symbol)(implicit ctx: Context)
     extends Message(ClassAndCompanionNameClashID) {
-    val kind = "Naming"
-    val msg = hl"Name clash: both ${cls.owner} and its companion object defines ${cls.name.stripModuleClassSuffix}"
-    val explanation = {
+    val kind: String = "Naming"
+    val msg: String = hl"Name clash: both ${cls.owner} and its companion object defines ${cls.name.stripModuleClassSuffix}"
+    val explanation: String = {
       val kind = if (cls.owner.is(Flags.Trait)) "trait" else "class"
 
       hl"""|A $kind and its companion object cannot both define a ${"class"}, ${"trait"} or ${"object"} with the same name:
@@ -1800,22 +1800,22 @@ object messages {
 
   case class TailrecNotApplicable(symbol: Symbol)(implicit ctx: Context)
     extends Message(TailrecNotApplicableID) {
-    val kind = "Syntax"
-    val symbolKind = symbol.showKind
-    val msg =
+    val kind: String = "Syntax"
+    val symbolKind: String = symbol.showKind
+    val msg: String =
       if (symbol.is(Method))
         hl"TailRec optimisation not applicable, $symbol is neither ${"private"} nor ${"final"}."
       else
         hl"TailRec optimisation not applicable, ${symbolKind} isn't a method."
-    val explanation =
+    val explanation: String =
       hl"A method annotated ${"@tailrec"} must be declared ${"private"} or ${"final"} so it can't be overridden."
   }
 
   case class FailureToEliminateExistential(tp: Type, tp1: Type, tp2: Type, boundSyms: List[Symbol])(implicit ctx: Context)
     extends Message(FailureToEliminateExistentialID) {
-    val kind = "Compatibility"
-    val msg = "Failure to eliminate existential type. Proceed at own risk."
-    val explanation = {
+    val kind: String = "Compatibility"
+    val msg: String = "Failure to eliminate existential type. Proceed at own risk."
+    val explanation: String = {
       val originalType = ctx.printer.dclsText(boundSyms, "; ").show
       hl"""original type    : $tp forSome ${originalType}
           |reduces to       : $tp1
@@ -1825,18 +1825,18 @@ object messages {
 
   case class OnlyFunctionsCanBeFollowedByUnderscore(tp: Type)(implicit ctx: Context)
     extends Message(OnlyFunctionsCanBeFollowedByUnderscoreID) {
-    val kind = "Syntax"
-    val msg = hl"Only function types can be followed by ${"_"} but the current expression has type $tp"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = hl"Only function types can be followed by ${"_"} but the current expression has type $tp"
+    val explanation: String =
       hl"""The syntax ${"x _"} is no longer supported if ${"x"} is not a function.
           |To convert to a function value, you need to explicitly write ${"() => x"}"""
   }
 
   case class MissingEmptyArgumentList(method: Symbol)(implicit ctx: Context)
     extends Message(MissingEmptyArgumentListID) {
-    val kind = "Syntax"
-    val msg = hl"$method must be called with ${"()"} argument"
-    val explanation = {
+    val kind: String = "Syntax"
+    val msg: String = hl"$method must be called with ${"()"} argument"
+    val explanation: String = {
       val codeExample =
         """def next(): T = ...
           |next     // is expanded to next()"""
@@ -1852,31 +1852,31 @@ object messages {
 
   case class DuplicateNamedTypeParameter(name: Name)(implicit ctx: Context)
     extends Message(DuplicateNamedTypeParameterID) {
-    val kind = "Syntax"
-    val msg = hl"Type parameter $name was defined multiple times."
-    val explanation = ""
+    val kind: String = "Syntax"
+    val msg: String = hl"Type parameter $name was defined multiple times."
+    val explanation: String = ""
   }
 
   case class UndefinedNamedTypeParameter(undefinedName: Name, definedNames: List[Name])(implicit ctx: Context)
     extends Message(UndefinedNamedTypeParameterID) {
-    val kind = "Syntax"
-    val msg = hl"Type parameter $undefinedName is undefined. Expected one of ${definedNames.map(_.show).mkString(", ")}."
-    val explanation = ""
+    val kind: String = "Syntax"
+    val msg: String = hl"Type parameter $undefinedName is undefined. Expected one of ${definedNames.map(_.show).mkString(", ")}."
+    val explanation: String = ""
   }
 
   case class IllegalStartOfStatement(isModifier: Boolean)(implicit ctx: Context) extends Message(IllegalStartOfStatementID) {
-    val kind = "Syntax"
-    val msg = {
+    val kind: String = "Syntax"
+    val msg: String = {
       val addendum = if (isModifier) ": no modifiers allowed here" else ""
       "Illegal start of statement" + addendum
     }
-    val explanation = "A statement is either an import, a definition or an expression."
+    val explanation: String = "A statement is either an import, a definition or an expression."
   }
 
   case class TraitIsExpected(symbol: Symbol)(implicit ctx: Context) extends Message(TraitIsExpectedID) {
-    val kind = "Syntax"
-    val msg = hl"$symbol is not a trait"
-    val explanation = {
+    val kind: String = "Syntax"
+    val msg: String = hl"$symbol is not a trait"
+    val explanation: String = {
       val errorCodeExample =
         """class A
           |class B
@@ -1902,23 +1902,23 @@ object messages {
   }
 
   case class TraitRedefinedFinalMethodFromAnyRef(method: Symbol)(implicit ctx: Context) extends Message(TraitRedefinedFinalMethodFromAnyRefID) {
-    val kind = "Syntax"
-    val msg = hl"Traits cannot redefine final $method from ${"class AnyRef"}."
-    val explanation = ""
+    val kind: String = "Syntax"
+    val msg: String = hl"Traits cannot redefine final $method from ${"class AnyRef"}."
+    val explanation: String = ""
   }
 
   case class PackageNameAlreadyDefined(pkg: Symbol)(implicit ctx: Context) extends Message(PackageNameAlreadyDefinedID) {
-    val msg = hl"${pkg} is already defined, cannot be a ${"package"}"
-    val kind = "Naming"
-    val explanation =
+    val msg: String = hl"${pkg} is already defined, cannot be a ${"package"}"
+    val kind: String = "Naming"
+    val explanation: String =
       hl"An ${"object"} cannot have the same name as an existing ${"package"}. Rename either one of them."
   }
 
   case class UnapplyInvalidNumberOfArguments(qual: untpd.Tree, argTypes: List[Type])(implicit ctx: Context)
     extends Message(UnapplyInvalidNumberOfArgumentsID) {
-    val kind = "Syntax"
-    val msg = hl"Wrong number of argument patterns for $qual; expected: ($argTypes%, %)"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = hl"Wrong number of argument patterns for $qual; expected: ($argTypes%, %)"
+    val explanation: String =
       hl"""The Unapply method of $qual was used with incorrect number of arguments.
           |Expected usage would be something like:
           |case $qual(${argTypes.map(_ => '_')}%, %) => ...
@@ -1928,16 +1928,16 @@ object messages {
   }
 
   case class StaticFieldsOnlyAllowedInObjects(member: Symbol)(implicit ctx: Context) extends Message(StaticFieldsOnlyAllowedInObjectsID) {
-    val msg = hl"${"@static"} $member in ${member.owner} must be defined inside an ${"object"}."
-    val kind = "Syntax"
-    val explanation =
+    val msg: String = hl"${"@static"} $member in ${member.owner} must be defined inside an ${"object"}."
+    val kind: String = "Syntax"
+    val explanation: String =
       hl"${"@static"} members are only allowed inside objects."
   }
 
   case class CyclicInheritance(symbol: Symbol, addendum: String)(implicit ctx: Context) extends Message(CyclicInheritanceID) {
-    val kind = "Syntax"
-    val msg = hl"Cyclic inheritance: $symbol extends itself$addendum"
-    val explanation = {
+    val kind: String = "Syntax"
+    val msg: String = hl"Cyclic inheritance: $symbol extends itself$addendum"
+    val explanation: String = {
       val codeExample = "class A extends A"
 
       hl"""Cyclic inheritance is prohibited in Dotty.
@@ -1952,9 +1952,9 @@ object messages {
   }
 
   case class BadSymbolicReference(denot: SymDenotation)(implicit ctx: Context) extends Message(BadSymbolicReferenceID) {
-    val kind = "Reference"
+    val kind: String = "Reference"
 
-    val msg = {
+    val msg: String = {
       val denotationOwner = denot.owner
       val denotationName = ctx.fresh.setSetting(ctx.settings.YdebugNames, true).printer.nameString(denot.name)
       val file = denot.symbol.associatedFile
@@ -1968,20 +1968,20 @@ object messages {
           |the classpath might be incompatible with the version used when compiling $src."""
     }
 
-    val explanation = ""
+    val explanation: String = ""
   }
 
   case class UnableToExtendSealedClass(pclazz: Symbol)(implicit ctx: Context) extends Message(UnableToExtendSealedClassID) {
-    val kind = "Syntax"
-    val msg = hl"Cannot extend ${"sealed"} $pclazz in a different source file"
-    val explanation = "A sealed class or trait can only be extended in the same file as its declaration"
+    val kind: String = "Syntax"
+    val msg: String = hl"Cannot extend ${"sealed"} $pclazz in a different source file"
+    val explanation: String = "A sealed class or trait can only be extended in the same file as its declaration"
   }
 
   case class SymbolHasUnparsableVersionNumber(symbol: Symbol, migrationMessage: String)(implicit ctx: Context)
   extends Message(SymbolHasUnparsableVersionNumberID) {
-    val kind = "Syntax"
-    val msg = hl"${symbol.showLocated} has an unparsable version number: $migrationMessage"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = hl"${symbol.showLocated} has an unparsable version number: $migrationMessage"
+    val explanation: String =
       hl"""$migrationMessage
           |
           |The ${symbol.showLocated} is marked with ${"@migration"} indicating it has changed semantics
@@ -1993,9 +1993,9 @@ object messages {
     symbol: Symbol,
     migrationVersion: ScalaVersion
   )(implicit ctx: Context) extends Message(SymbolChangedSemanticsInVersionID) {
-    val kind = "Syntax"
-    val msg = hl"${symbol.showLocated} has changed semantics in version $migrationVersion"
-    val explanation = {
+    val kind: String = "Syntax"
+    val msg: String = hl"${symbol.showLocated} has changed semantics in version $migrationVersion"
+    val explanation: String = {
       hl"""The ${symbol.showLocated} is marked with ${"@migration"} indicating it has changed semantics
           |between versions and the ${"-Xmigration"} settings is used to warn about constructs
           |whose behavior may have changed since version change."""
@@ -2004,10 +2004,10 @@ object messages {
 
   case class UnableToEmitSwitch(tooFewCases: Boolean)(implicit ctx: Context)
   extends Message(UnableToEmitSwitchID) {
-    val kind = "Syntax"
-    val tooFewStr = if (tooFewCases) " since there are not enough cases" else ""
-    val msg = hl"Could not emit switch for ${"@switch"} annotated match$tooFewStr"
-    val explanation = {
+    val kind: String = "Syntax"
+    val tooFewStr: String = if (tooFewCases) " since there are not enough cases" else ""
+    val msg: String = hl"Could not emit switch for ${"@switch"} annotated match$tooFewStr"
+    val explanation: String = {
       val codeExample =
         """val ConstantB = 'B'
           |final val ConstantC = 'C'
@@ -2033,17 +2033,17 @@ object messages {
   }
 
   case class MissingCompanionForStatic(member: Symbol)(implicit ctx: Context) extends Message(MissingCompanionForStaticID) {
-    val msg = hl"${member.owner} does not have a companion class"
-    val kind = "Syntax"
-    val explanation =
+    val msg: String = hl"${member.owner} does not have a companion class"
+    val kind: String = "Syntax"
+    val explanation: String =
       hl"An object that contains ${"@static"} members must have a companion class."
   }
 
   case class PolymorphicMethodMissingTypeInParent(rsym: Symbol, parentSym: Symbol)(implicit ctx: Context)
   extends Message(PolymorphicMethodMissingTypeInParentID) {
-    val kind = "Syntax"
-    val msg = hl"polymorphic refinement $rsym without matching type in parent $parentSym is no longer allowed"
-    val explanation =
+    val kind: String = "Syntax"
+    val msg: String = hl"polymorphic refinement $rsym without matching type in parent $parentSym is no longer allowed"
+    val explanation: String =
       hl"""Polymorphic $rsym is not allowed in the structural refinement of $parentSym because
           |$rsym does not override any method in $parentSym. Structural refinement does not allow for
           |polymorphic methods."""
@@ -2051,26 +2051,26 @@ object messages {
 
   case class ParamsNoInline(owner: Symbol)(implicit ctx: Context)
     extends Message(ParamsNoInlineID) {
-    val kind = "Syntax"
-    val msg = hl"""${"inline"} modifier can only be used for parameters of inline methods"""
-    val explanation = ""
+    val kind: String = "Syntax"
+    val msg: String = hl"""${"inline"} modifier can only be used for parameters of inline methods"""
+    val explanation: String = ""
   }
 
   case class JavaSymbolIsNotAValue(symbol: Symbol)(implicit ctx: Context) extends Message(JavaSymbolIsNotAValueID) {
-    val kind = "Type Mismatch"
-    val msg = {
+    val kind: String = "Type Mismatch"
+    val msg: String = {
       val kind =
         if (symbol is Package) hl"$symbol"
         else hl"Java defined ${"class " + symbol.name}"
 
       s"$kind is not a value"
     }
-    val explanation = ""
+    val explanation: String = ""
   }
 
   case class DoubleDeclaration(decl: Symbol, previousDecl: Symbol)(implicit ctx: Context) extends Message(DoubleDeclarationID) {
-    val kind = "Duplicate Symbol"
-    val msg = {
+    val kind: String = "Duplicate Symbol"
+    val msg: String = {
       val details = if (decl.isRealMethod && previousDecl.isRealMethod) {
         // compare the signatures when both symbols represent methods
         decl.signature.matchDegree(previousDecl.signature) match {
@@ -2081,32 +2081,32 @@ object messages {
       } else ""
       hl"${decl.showLocated} is already defined as ${previousDecl.showDcl} at line ${previousDecl.pos.line + 1}." + details
     }
-    val explanation = ""
+    val explanation: String = ""
   }
 
   case class ImportRenamedTwice(ident: untpd.Ident)(implicit ctx: Context) extends Message(ImportRenamedTwiceID) {
-    val kind = "Syntax"
+    val kind: String = "Syntax"
     val msg: String = s"${ident.show} is renamed twice on the same import line."
     val explanation: String = ""
   }
 
   case class TypeTestAlwaysSucceeds(foundCls: Symbol, testCls: Symbol)(implicit ctx: Context) extends Message(TypeTestAlwaysSucceedsID) {
-    val kind = "Syntax"
-    val msg = {
+    val kind: String = "Syntax"
+    val msg: String = {
       val addendum =
         if (foundCls != testCls) s" is a subtype of $testCls"
         else " is the same as the tested type"
       s"The highlighted type test will always succeed since the scrutinee type ($foundCls)" + addendum
     }
-    val explanation = ""
+    val explanation: String = ""
   }
 
   // Relative of CyclicReferenceInvolvingImplicit and RecursiveValueNeedsResultType
   case class TermMemberNeedsResultTypeForImplicitSearch(cycleSym: Symbol)(implicit ctx: Context)
     extends Message(TermMemberNeedsNeedsResultTypeForImplicitSearchID) {
-    val kind = "Cyclic"
-    val msg = hl"""$cycleSym needs result type because its right-hand side attempts implicit search"""
-    val explanation =
+    val kind: String = "Cyclic"
+    val msg: String = hl"""$cycleSym needs result type because its right-hand side attempts implicit search"""
+    val explanation: String =
       hl"""|The right hand-side of $cycleSym's definition requires an implicit search at the highlighted position.
            |To avoid this error, give `$cycleSym` an explicit type.
            |""".stripMargin
diff --git a/compiler/src/dotty/tools/dotc/rewrites/Rewrites.scala b/compiler/src/dotty/tools/dotc/rewrites/Rewrites.scala
index b4cc9c8a192c..6dc080502a2e 100644
--- a/compiler/src/dotty/tools/dotc/rewrites/Rewrites.scala
+++ b/compiler/src/dotty/tools/dotc/rewrites/Rewrites.scala
@@ -3,7 +3,7 @@ package rewrites
 
 import util.{SourceFile, Positions}
 import Positions.Position
-import core.Contexts.{Context, FreshContext}
+import core.Contexts.Context
 import collection.mutable
 import scala.annotation.tailrec
 
@@ -74,7 +74,7 @@ object Rewrites {
 
   /** If -rewrite is set, apply all patches and overwrite patched source files.
    */
-  def writeBack()(implicit ctx: Context) =
+  def writeBack()(implicit ctx: Context): Unit =
     for (rewrites <- ctx.settings.rewrite.value; source <- rewrites.patched.keys) {
       ctx.echo(s"[patched file ${source.file.path}]")
       rewrites.patched(source).writeBack()
diff --git a/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala b/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala
index d1fbf9f2e39a..ee43e7a37932 100644
--- a/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala
+++ b/compiler/src/dotty/tools/dotc/sbt/ExtractAPI.scala
@@ -46,7 +46,7 @@ class ExtractAPI extends Phase {
   // after `PostTyper` (unlike `ExtractDependencies`, the simplication to trees
   // done by `PostTyper` do not affect this phase because it only cares about
   // definitions, and `PostTyper` does not change definitions).
-  override def runsAfter = Set(transform.PostTyper.name)
+  override def runsAfter: Set[String] = Set(transform.PostTyper.name)
 
   override def run(implicit ctx: Context): Unit = {
     val unit = ctx.compilationUnit
@@ -164,9 +164,9 @@ private class ExtractAPICollector(implicit val ctx: Context) extends ThunkHolder
     api.Annotated.of(tp, Array(marker))
   private def marker(name: String) =
     api.Annotation.of(api.Constant.of(Constants.emptyType, name), Array())
-  val orMarker = marker("Or")
-  val byNameMarker = marker("ByName")
-  val matchMarker = marker("Match")
+  private val orMarker = marker("Or")
+  private val byNameMarker = marker("ByName")
+  private val matchMarker = marker("Match")
 
   /** Extract the API representation of a source file */
   def apiSource(tree: Tree): Seq[api.ClassLike] = {
diff --git a/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala b/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala
index 553a04a12df4..f4bbbafe61b1 100644
--- a/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala
+++ b/compiler/src/dotty/tools/dotc/sbt/ExtractDependencies.scala
@@ -441,14 +441,14 @@ private class ExtractDependenciesCollector extends tpd.TreeTraverser { thisTreeT
     }
   }
 
-  def addTypeDependency(tpe: Type)(implicit ctx: Context) = {
+  def addTypeDependency(tpe: Type)(implicit ctx: Context): Unit = {
     val traverser = new TypeDependencyTraverser {
       def addDependency(symbol: Symbol) = addMemberRefDependency(symbol)
     }
     traverser.traverse(tpe)
   }
 
-  def addPatMatDependency(tpe: Type)(implicit ctx: Context) = {
+  def addPatMatDependency(tpe: Type)(implicit ctx: Context): Unit = {
     val traverser = new TypeDependencyTraverser {
       def addDependency(symbol: Symbol) =
         if (!ignoreDependency(symbol) && symbol.is(Sealed)) {
diff --git a/compiler/src/dotty/tools/dotc/sbt/ShowAPI.scala b/compiler/src/dotty/tools/dotc/sbt/ShowAPI.scala
index 35bdc8594066..110024435977 100644
--- a/compiler/src/dotty/tools/dotc/sbt/ShowAPI.scala
+++ b/compiler/src/dotty/tools/dotc/sbt/ShowAPI.scala
@@ -16,9 +16,9 @@ import scala.util.Try
 object DefaultShowAPI {
   private lazy val defaultNesting = Try { java.lang.Integer.parseInt(sys.props.get("sbt.inc.apidiff.depth").get) } getOrElse 2
 
-  def apply(d: Definition) = ShowAPI.showDefinition(d)(defaultNesting)
-  def apply(d: Type) = ShowAPI.showType(d)(defaultNesting)
-  def apply(a: ClassLike) = ShowAPI.showApi(a)(defaultNesting)
+  def apply(d: Definition): String = ShowAPI.showDefinition(d)(defaultNesting)
+  def apply(d: Type): String = ShowAPI.showType(d)(defaultNesting)
+  def apply(a: ClassLike): String = ShowAPI.showApi(a)(defaultNesting)
 }
 
 object ShowAPI {
@@ -27,7 +27,7 @@ object ShowAPI {
   private def truncateDecls(decls: Array[ClassDefinition]): Array[ClassDefinition] = if (numDecls <= 0) decls else decls.take(numDecls)
   private def lines(ls: Seq[String]): String = ls.mkString("\n", "\n", "\n")
 
-  def showApi(c: ClassLike)(implicit nesting: Int) =
+  def showApi(c: ClassLike)(implicit nesting: Int): String =
     showDefinition(c)
 
   def showDefinition(d: Definition)(implicit nesting: Int): String = d match {
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/CaseDefOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/CaseDefOpsImpl.scala
index bf8c82239265..0ad6f123be72 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/CaseDefOpsImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/CaseDefOpsImpl.scala
@@ -1,6 +1,5 @@
 package dotty.tools.dotc.tastyreflect
 
-import dotty.tools.dotc.ast.tpd
 
 trait CaseDefOpsImpl extends scala.tasty.reflect.CaseDefOps with TastyCoreImpl with Helpers {
 
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/ConstantOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/ConstantOpsImpl.scala
index 179e40a53c79..fdb4e5472580 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/ConstantOpsImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/ConstantOpsImpl.scala
@@ -2,7 +2,6 @@ package dotty.tools.dotc.tastyreflect
 
 import dotty.tools.dotc.core.Constants
 
-import scala.tasty.util.Show
 
 trait ConstantOpsImpl extends scala.tasty.reflect.ConstantOps with TastyCoreImpl {
 
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/ContextOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/ContextOpsImpl.scala
index c794f39b5e1f..923af0575807 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/ContextOpsImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/ContextOpsImpl.scala
@@ -1,12 +1,10 @@
 package dotty.tools.dotc.tastyreflect
 
-import dotty.tools.dotc.core.Contexts
-import dotty.tools.dotc.tastyreflect.FromSymbol.definitionFromSym
 import dotty.tools.dotc.util.{Positions, SourcePosition}
 
 trait ContextOpsImpl extends scala.tasty.reflect.ContextOps with TastyCoreImpl {
 
-  val rootContext: Contexts.Context
+  val rootContext: Context
 
   def ContextDeco(ctx: Context): ContextAPI = new ContextAPI {
     def owner: Symbol = ctx.owner
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/PatternOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/PatternOpsImpl.scala
index 0eed6293b3f5..30110a5db0b3 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/PatternOpsImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/PatternOpsImpl.scala
@@ -2,9 +2,6 @@ package dotty.tools.dotc.tastyreflect
 
 import dotty.tools.dotc.ast.{Trees, tpd}
 import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.core.Types
-
-import scala.tasty.util.Show
 
 trait PatternOpsImpl extends scala.tasty.reflect.PatternOps with TastyCoreImpl {
 
@@ -12,7 +9,7 @@ trait PatternOpsImpl extends scala.tasty.reflect.PatternOps with TastyCoreImpl {
 
   def PatternDeco(pattern: Pattern): PatternAPI = new PatternAPI {
     def pos(implicit ctx: Context): Position = pattern.pos
-    def tpe(implicit ctx: Context): Types.Type = pattern.tpe.stripTypeVar
+    def tpe(implicit ctx: Context): Type = pattern.tpe.stripTypeVar
   }
 
   object Pattern extends PatternModule {
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/PrintersImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/PrintersImpl.scala
index d86669b083c9..e65a7cdbe5f0 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/PrintersImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/PrintersImpl.scala
@@ -1,7 +1,5 @@
 package dotty.tools.dotc.tastyreflect
 
-import dotty.tools.dotc.core.Contexts
-
 import scala.tasty.util.{Show, ShowExtractors, ShowSourceCode}
 
 trait PrintersImpl extends scala.tasty.reflect.Printers with scala.tasty.reflect.TastyCore { tasty: TastyImpl =>
@@ -12,37 +10,37 @@ trait PrintersImpl extends scala.tasty.reflect.Printers with scala.tasty.reflect
 
   /** Adds `show` as an extension method of a `Tree` */
   def TreeShowDeco(tree: Tree): ShowAPI = new ShowAPI {
-    def show(implicit ctx: Contexts.Context, s: Show[tasty.type]): String = s.showTree(tree)
+    def show(implicit ctx: Context, s: Show[tasty.type]): String = s.showTree(tree)
   }
 
   /** Adds `show` as an extension method of a `TypeOrBoundsTree` */
   def TypeOrBoundsTreeShowDeco(tpt: TypeOrBoundsTree): ShowAPI = new ShowAPI {
-    def show(implicit ctx: Contexts.Context, s: Show[tasty.type]): String = s.showTypeOrBoundsTree(tpt)
+    def show(implicit ctx: Context, s: Show[tasty.type]): String = s.showTypeOrBoundsTree(tpt)
   }
 
   /** Adds `show` as an extension method of a `TypeOrBounds` */
   def TypeOrBoundsShowDeco(tpe: TypeOrBounds): ShowAPI = new ShowAPI {
-    def show(implicit ctx: Contexts.Context, s: Show[tasty.type]): String = s.showTypeOrBounds(tpe)
+    def show(implicit ctx: Context, s: Show[tasty.type]): String = s.showTypeOrBounds(tpe)
   }
 
   /** Adds `show` as an extension method of a `CaseDef` */
   def CaseDefShowDeco(caseDef: CaseDef): ShowAPI = new ShowAPI {
-    def show(implicit ctx: Contexts.Context, s: Show[tasty.type]): String = s.showCaseDef(caseDef)
+    def show(implicit ctx: Context, s: Show[tasty.type]): String = s.showCaseDef(caseDef)
   }
 
   /** Adds `show` as an extension method of a `Pattern` */
   def PatternShowDeco(pattern: Pattern): ShowAPI = new ShowAPI {
-    def show(implicit ctx: Contexts.Context, s: Show[tasty.type]): String = s.showPattern(pattern)
+    def show(implicit ctx: Context, s: Show[tasty.type]): String = s.showPattern(pattern)
   }
 
   /** Adds `show` as an extension method of a `Constant` */
   def ConstantShowDeco(const: Constant): ShowAPI = new ShowAPI {
-    def show(implicit ctx: Contexts.Context, s: Show[tasty.type]): String = s.showConstant(const)
+    def show(implicit ctx: Context, s: Show[tasty.type]): String = s.showConstant(const)
   }
 
   /** Adds `show` as an extension method of a `Symbol` */
   def SymbolShowDeco(symbol: Symbol): ShowAPI = new ShowAPI {
-    def show(implicit ctx: Contexts.Context, s: Show[tasty.type]): String = s.showSymbol(symbol)
+    def show(implicit ctx: Context, s: Show[tasty.type]): String = s.showSymbol(symbol)
   }
 
 }
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/QuotedOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/QuotedOpsImpl.scala
index abe93835ef36..bcb599180c8d 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/QuotedOpsImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/QuotedOpsImpl.scala
@@ -1,6 +1,6 @@
 package dotty.tools.dotc.tastyreflect
 
-import dotty.tools.dotc.core.Contexts
+import dotty.tools.dotc.core.Contexts.FreshContext
 import dotty.tools.dotc.core.quoted.PickledQuotes
 import dotty.tools.dotc.reporting.Reporter
 import dotty.tools.dotc.reporting.diagnostic.MessageContainer
@@ -22,11 +22,11 @@ trait QuotedOpsImpl extends scala.tasty.reflect.QuotedOps with TastyCoreImpl {
       new scala.quoted.Exprs.TastyTreeExpr(term).asInstanceOf[scala.quoted.Expr[T]]
     }
 
-    private def typecheck[T: scala.quoted.Type](ctx: Contexts.Context): Unit = {
-      implicit val ctx0: Contexts.FreshContext = ctx.fresh
+    private def typecheck[T: scala.quoted.Type](ctx: Context): Unit = {
+      implicit val ctx0: FreshContext = ctx.fresh
       ctx0.setTyperState(ctx0.typerState.fresh())
       ctx0.typerState.setReporter(new Reporter {
-        def doReport(m: MessageContainer)(implicit ctx: Contexts.Context): Unit = ()
+        def doReport(m: MessageContainer)(implicit ctx: Context): Unit = ()
       })
       val tp = QuotedTypeDeco(implicitly[scala.quoted.Type[T]]).toTasty
       ctx0.typer.typed(term, tp.tpe)
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/StandardDefinitions.scala b/compiler/src/dotty/tools/dotc/tastyreflect/StandardDefinitions.scala
index 8a73c60d67b4..f8597b71d79e 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/StandardDefinitions.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/StandardDefinitions.scala
@@ -2,7 +2,6 @@ package dotty.tools.dotc.tastyreflect
 
 import dotty.tools.dotc.core.Symbols._
 
-import dotty.tools.dotc.tastyreflect.FromSymbol._
 
 trait StandardDefinitions extends scala.tasty.reflect.StandardDefinitions {
     tasty: TastyImpl =>
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala
index 75d7712f591b..bc94a4ac21d5 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/TreeOpsImpl.scala
@@ -3,7 +3,6 @@ package dotty.tools.dotc.tastyreflect
 import dotty.tools.dotc.ast.{Trees, tpd}
 import dotty.tools.dotc.core
 import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core._
 import dotty.tools.dotc.tastyreflect.FromSymbol.{definitionFromSym, packageDefFromSym}
 
@@ -188,7 +187,7 @@ trait TreeOpsImpl extends scala.tasty.reflect.TreeOps with TastyCoreImpl with He
 
   def TermDeco(term: Term): TermAPI = new TermAPI {
     def pos(implicit ctx: Context): Position = term.pos
-    def tpe(implicit ctx: Context): Types.Type = term.tpe
+    def tpe(implicit ctx: Context): Type = term.tpe
     def underlyingArgument(implicit ctx: Context): Term = {
       import tpd._
       term.underlyingArgument
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/TypeOrBoundsOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/TypeOrBoundsOpsImpl.scala
index 6fdffc033137..6ff1a7147082 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/TypeOrBoundsOpsImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/TypeOrBoundsOpsImpl.scala
@@ -1,8 +1,6 @@
 package dotty.tools.dotc.tastyreflect
 
-import dotty.tools.dotc.core.Symbols.Symbol
 import dotty.tools.dotc.core.{Names, Types}
-import dotty.tools.dotc.tastyreflect.FromSymbol.definitionFromSym
 
 trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with TastyCoreImpl {
 
@@ -27,7 +25,7 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with Tasty
     def resultTpe(implicit ctx: Context): Type = tpe.resType
   }
 
-  def TypeLambdaDeco(tpe: Types.TypeLambda): TypeLambdaAPI = new TypeLambdaAPI {
+  def TypeLambdaDeco(tpe: TypeLambda): TypeLambdaAPI = new TypeLambdaAPI {
     def paramNames(implicit ctx: Context): List[String] = tpe.paramNames.map(_.toString)
     def paramTypes(implicit ctx: Context): List[TypeBounds] = tpe.paramInfos
     def resultTpe(implicit ctx: Context): Type = tpe.resType
@@ -35,7 +33,7 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with Tasty
 
   object IsType extends IsTypeExtractor {
     def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[Type] = x match {
-      case x: Types.TypeBounds => None
+      case x: TypeBounds => None
       case x if x == Types.NoPrefix => None
       case _ => Some(x)
     }
@@ -191,14 +189,14 @@ trait TypeOrBoundsOpsImpl extends scala.tasty.reflect.TypeOrBoundsOps with Tasty
 
   object IsTypeBounds extends IsTypeBoundsExtractor {
     def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[TypeBounds] = x match {
-      case x: Types.TypeBounds => Some(x)
+      case x: TypeBounds => Some(x)
       case _ => None
     }
   }
 
   object TypeBounds extends TypeBoundsExtractor {
     def unapply(x: TypeOrBounds)(implicit ctx: Context): Option[(Type, Type)] = x match {
-      case x: Types.TypeBounds => Some(x.lo, x.hi)
+      case x: TypeBounds => Some(x.lo, x.hi)
       case _ => None
     }
   }
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/TypeOrBoundsTreesOpsImpl.scala b/compiler/src/dotty/tools/dotc/tastyreflect/TypeOrBoundsTreesOpsImpl.scala
index 7381cba384eb..c39c13f97284 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/TypeOrBoundsTreesOpsImpl.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/TypeOrBoundsTreesOpsImpl.scala
@@ -5,7 +5,6 @@ import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.Types
 
-import scala.tasty.util.Show
 
 trait TypeOrBoundsTreesOpsImpl extends scala.tasty.reflect.TypeOrBoundsTreeOps with TastyCoreImpl {
 
@@ -19,7 +18,7 @@ trait TypeOrBoundsTreesOpsImpl extends scala.tasty.reflect.TypeOrBoundsTreeOps w
 
   def TypeTreeDeco(tpt: TypeTree): TypeTreeAPI = new TypeTreeAPI {
     def pos(implicit ctx: Context): Position = tpt.pos
-    def tpe(implicit ctx: Context): Types.Type = tpt.tpe.stripTypeVar
+    def tpe(implicit ctx: Context): Type = tpt.tpe.stripTypeVar
   }
 
   object IsTypeTree extends IsTypeTreeExtractor {
diff --git a/compiler/src/dotty/tools/dotc/tastyreflect/package.scala b/compiler/src/dotty/tools/dotc/tastyreflect/package.scala
index 187ffb8d176c..d13dc0f322b0 100644
--- a/compiler/src/dotty/tools/dotc/tastyreflect/package.scala
+++ b/compiler/src/dotty/tools/dotc/tastyreflect/package.scala
@@ -4,6 +4,7 @@ import dotty.tools.dotc.ast.Trees.{Tree, Untyped}
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Symbols.Symbol
 import dotty.tools.dotc.core.Types.Type
+import dotty.tools.dotc.core.SymDenotations.SymDenotation
 
 package object tastyreflect {
 
@@ -12,7 +13,8 @@ package object tastyreflect {
   /** Represents the symbol of a definition in tree form */
   case class PackageDefinitionImpl[-T >: Untyped] private[tastyreflect] (sym: Symbol) extends Tree[T] {
     type ThisTree[-T >: Untyped] = PackageDefinitionImpl[T]
-    override def denot(implicit ctx: Context) = sym.denot
+
+    override def denot(implicit ctx: Context): SymDenotation = sym.denot
   }
 
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala b/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala
index 1e4bd8730559..03782a0436bc 100644
--- a/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala
+++ b/compiler/src/dotty/tools/dotc/transform/AccessProxies.scala
@@ -9,11 +9,9 @@ import Names._
 import NameOps._
 import Decorators._
 import TypeUtils._
-import Annotations.Annotation
 import Types._
 import NameKinds.ClassifiedNameKind
 import ast.Trees._
-import util.Property
 import util.Positions.Position
 import config.Printers.transforms
 
@@ -30,7 +28,7 @@ abstract class AccessProxies {
   /** Given the name of an accessor, is the receiver of the call to accessed obtained
    *  as a parameterer?
    */
-  protected def passReceiverAsArg(accessorName: Name)(implicit ctx: Context) = false
+  protected def passReceiverAsArg(accessorName: Name)(implicit ctx: Context): Boolean = false
 
   /** The accessor definitions that need to be added to class `cls`
    *  As a side-effect, this method removes entries from the `accessedBy` map.
@@ -84,7 +82,7 @@ abstract class AccessProxies {
     }
 
     /** An accessor symbol, create a fresh one unless one exists already */
-    protected def accessorSymbol(owner: Symbol, accessorName: TermName, accessorInfo: Type, accessed: Symbol)(implicit ctx: Context) = {
+    protected def accessorSymbol(owner: Symbol, accessorName: TermName, accessorInfo: Type, accessed: Symbol)(implicit ctx: Context): Symbol = {
       def refersToAccessed(sym: Symbol) = accessedBy.get(sym).contains(accessed)
       owner.info.decl(accessorName).suchThat(refersToAccessed).symbol.orElse {
         val acc = newAccessorSymbol(owner, accessorName, accessorInfo, accessed.pos)
diff --git a/compiler/src/dotty/tools/dotc/transform/ArrayConstructors.scala b/compiler/src/dotty/tools/dotc/transform/ArrayConstructors.scala
index 00e2473d8ae1..b524d060d4a2 100644
--- a/compiler/src/dotty/tools/dotc/transform/ArrayConstructors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ArrayConstructors.scala
@@ -4,22 +4,12 @@ package transform
 import core._
 import MegaPhase._
 import Contexts.Context
-import Flags._
-import SymUtils._
 import Symbols._
-import SymDenotations._
 import Types._
-import Decorators._
-import DenotTransformers._
 import StdNames._
-import NameOps._
 import ast.Trees._
 import dotty.tools.dotc.ast.tpd
-import util.Positions._
-import Names._
 
-import collection.mutable
-import ResolveSuper._
 
 import scala.collection.immutable.::
 
diff --git a/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala b/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala
index c5011bdb716a..b1ba4d987131 100644
--- a/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala
+++ b/compiler/src/dotty/tools/dotc/transform/AugmentScala2Traits.scala
@@ -7,7 +7,6 @@ import Contexts.Context
 import Flags._
 import SymUtils._
 import Symbols._
-import SymDenotations._
 import Types._
 import Decorators._
 import DenotTransformers._
@@ -15,10 +14,9 @@ import Annotations._
 import StdNames._
 import NameOps._
 import NameKinds.{ExpandedName, TraitSetterName}
-import ast.Trees._
 
 object AugmentScala2Traits {
-  val name = "augmentScala2Traits"
+  val name: String = "augmentScala2Traits"
 }
 
 /** This phase augments Scala2 traits with implementation classes and with additional members
@@ -35,13 +33,13 @@ object AugmentScala2Traits {
 class AugmentScala2Traits extends MiniPhase with IdentityDenotTransformer with FullParameterization { thisPhase =>
   import ast.tpd._
 
-  override def changesMembers = true
+  override def changesMembers: Boolean = true
 
   override def phaseName: String = AugmentScala2Traits.name
 
-  override def rewiredTarget(referenced: Symbol, derived: Symbol)(implicit ctx: Context) = NoSymbol
+  override def rewiredTarget(referenced: Symbol, derived: Symbol)(implicit ctx: Context): Symbol = NoSymbol
 
-  override def transformTemplate(impl: Template)(implicit ctx: Context) = {
+  override def transformTemplate(impl: Template)(implicit ctx: Context): Template = {
     val cls = impl.symbol.owner.asClass
     for (mixin <- cls.mixins)
       if (mixin.is(Scala2x))
diff --git a/compiler/src/dotty/tools/dotc/transform/Bridges.scala b/compiler/src/dotty/tools/dotc/transform/Bridges.scala
index 8e9c7436a96e..104c1fd0a21b 100644
--- a/compiler/src/dotty/tools/dotc/transform/Bridges.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Bridges.scala
@@ -3,13 +3,12 @@ package dotc
 package transform
 
 import core._
-import Symbols._, Types._, Contexts._, Decorators._, SymDenotations._, Flags._, Scopes._
+import Symbols._, Types._, Contexts._, Decorators._, Flags._, Scopes._
 import DenotTransformers._
 import ast.untpd
 import collection.{mutable, immutable}
-import TypeErasure._
-import ValueClasses.isDerivedValueClass
 import ShortcutImplicits._
+import util.Positions.Position
 
 /** A helper class for generating bridge methods in class `root`. */
 class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Context) {
@@ -27,7 +26,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
      *  only in classes, never in traits.
      */
     override def parents = Array(root.superClass)
-    
+
     override def exclude(sym: Symbol) =
       !sym.is(MethodOrModule) ||
       isImplicitShortcut(sym) ||
@@ -41,7 +40,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
   private val bridgesScope = newScope
   private val bridgeTarget = newMutableSymbolMap[Symbol]
 
-  def bridgePosFor(member: Symbol) =
+  def bridgePosFor(member: Symbol): Position =
     if (member.owner == root && member.pos.exists) member.pos else root.pos
 
   /** Add a bridge between `member` and `other`, where `member` overrides `other`
@@ -119,7 +118,7 @@ class Bridges(root: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
     while (opc.hasNext) {
       if (!opc.overriding.is(Deferred)) {
         addBridgeIfNeeded(opc.overriding, opc.overridden)
-        
+
         if (needsImplicitShortcut(opc.overriding)(ectx))
           // implicit shortcuts do not show up in the Bridges cursor, since they
           // are created only when referenced. Therefore we need to generate a bridge
diff --git a/compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala b/compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala
index 919a1961f5fa..8356539f9000 100644
--- a/compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ByNameClosures.scala
@@ -2,12 +2,9 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import Symbols._
-import SymDenotations._
 import Contexts._
 import Types._
 import Flags._
-import Decorators._
 import DenotTransformers.IdentityDenotTransformer
 import core.StdNames.nme
 
@@ -36,5 +33,5 @@ class ByNameClosures extends TransformByNameApply with IdentityDenotTransformer
 }
 
 object ByNameClosures {
-  val name = "byNameClosures"
+  val name: String = "byNameClosures"
 }
\ No newline at end of file
diff --git a/compiler/src/dotty/tools/dotc/transform/CapturedVars.scala b/compiler/src/dotty/tools/dotc/transform/CapturedVars.scala
index 3e1977ed5e1a..9f03c39f92ac 100644
--- a/compiler/src/dotty/tools/dotc/transform/CapturedVars.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CapturedVars.scala
@@ -5,19 +5,14 @@ import MegaPhase._
 import core.DenotTransformers._
 import core.Symbols._
 import core.Contexts._
-import core.Types._
 import core.Flags._
 import core.Decorators._
-import core.SymDenotations._
 import core.StdNames.nme
 import core.Names._
-import core.NameOps._
 import core.NameKinds.TempResultName
 import ast.Trees._
-import SymUtils._
 import util.Store
-import collection.{ mutable, immutable }
-import collection.mutable.{ LinkedHashMap, LinkedHashSet, TreeSet }
+import collection.mutable
 
 /** This phase translates variables that are captured in closures to
  *  heap-allocated refs.
@@ -31,7 +26,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
   private var Captured: Store.Location[collection.Set[Symbol]] = _
   private def captured(implicit ctx: Context) = ctx.store(Captured)
 
-  override def initContext(ctx: FreshContext) =
+  override def initContext(ctx: FreshContext): Unit =
     Captured = ctx.addLocation(Set.empty)
 
   private class RefInfo(implicit ctx: Context) {
@@ -76,7 +71,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
     }
   }
 
-  override def prepareForUnit(tree: Tree)(implicit ctx: Context) = {
+  override def prepareForUnit(tree: Tree)(implicit ctx: Context): Context = {
     val captured = (new CollectCaptured)
       .runOver(ctx.compilationUnit.tpdTree)(ctx.withPhase(thisPhase))
     ctx.fresh.updateStore(Captured, captured)
@@ -93,7 +88,7 @@ class CapturedVars extends MiniPhase with IdentityDenotTransformer { thisPhase =
     else refMap(defn.ObjectClass)
   }
 
-  override def prepareForValDef(vdef: ValDef)(implicit ctx: Context) = {
+  override def prepareForValDef(vdef: ValDef)(implicit ctx: Context): Context = {
     val sym = vdef.symbol(ctx.withPhase(thisPhase))
     if (captured contains sym) {
       val newd = sym.denot(ctx.withPhase(thisPhase)).copySymDenotation(
diff --git a/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala b/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala
index 49be540f92ab..a44eac861cea 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckReentrant.scala
@@ -2,24 +2,11 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import Names._
 import dotty.tools.dotc.transform.MegaPhase._
-import ast.Trees._
 import Flags._
-import Types._
-import Constants.Constant
 import Contexts.Context
 import Symbols._
-import SymDenotations._
 import Decorators._
-import dotty.tools.dotc.core.Annotations.ConcreteAnnotation
-import dotty.tools.dotc.core.Denotations.SingleDenotation
-import scala.collection.mutable
-import DenotTransformers._
-import typer.Checking
-import Names.Name
-import NameOps._
-import StdNames._
 
 
 /** A no-op transform that checks whether the compiled sources are re-entrant.
@@ -43,7 +30,7 @@ import StdNames._
 class CheckReentrant extends MiniPhase {
   import ast.tpd._
 
-  override def phaseName = "checkReentrant"
+  override def phaseName: String = "checkReentrant"
 
   private[this] var shared: Set[Symbol] = Set()
   private[this] var seen: Set[ClassSymbol] = Set()
@@ -54,7 +41,7 @@ class CheckReentrant extends MiniPhase {
   private val unsharedAnnot = new CtxLazy(implicit ctx =>
     ctx.requiredClass("scala.annotation.internal.unshared"))
 
-  def isIgnored(sym: Symbol)(implicit ctx: Context) =
+  def isIgnored(sym: Symbol)(implicit ctx: Context): Boolean =
     sym.hasAnnotation(sharableAnnot()) ||
     sym.hasAnnotation(unsharedAnnot())
 
diff --git a/compiler/src/dotty/tools/dotc/transform/CheckStatic.scala b/compiler/src/dotty/tools/dotc/transform/CheckStatic.scala
index cb27f2d7323b..c63294ff6b19 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckStatic.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckStatic.scala
@@ -25,7 +25,7 @@ import reporting.diagnostic.messages.{MissingCompanionForStatic, StaticFieldsOnl
 class CheckStatic extends MiniPhase {
   import ast.tpd._
 
-  override def phaseName = CheckStatic.name
+  override def phaseName: String = CheckStatic.name
 
   override def transformTemplate(tree: tpd.Template)(implicit ctx: Context): tpd.Tree = {
     val defns = tree.body.collect{case t: ValOrDefDef => t}
@@ -79,5 +79,5 @@ class CheckStatic extends MiniPhase {
 }
 
 object CheckStatic {
-  val name = "checkStatic"
+  val name: String = "checkStatic"
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/ClassOf.scala b/compiler/src/dotty/tools/dotc/transform/ClassOf.scala
index 493ff8df638d..4938d4a993d2 100644
--- a/compiler/src/dotty/tools/dotc/transform/ClassOf.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ClassOf.scala
@@ -2,11 +2,8 @@ package dotty.tools.dotc
 package transform
 
 import ast.tpd
-import core.Constants.Constant
 import core.Contexts.Context
-import core.StdNames.nme
-import core.Symbols.{defn,TermSymbol}
-import core.TypeErasure
+import core.Symbols.defn
 import MegaPhase._
 
 /** Rewrite `classOf` calls as follow:
diff --git a/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala b/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala
index 4b3ad0eb8255..8942d7ae6fcb 100644
--- a/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CollectEntryPoints.scala
@@ -2,20 +2,13 @@ package dotty.tools.dotc.transform
 
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.Context
-import scala.collection.mutable.ListBuffer
-import dotty.tools.dotc.core.{Scopes, Flags}
-import dotty.tools.dotc.core.Symbols.NoSymbol
-import scala.annotation.tailrec
+import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core._
 import Symbols._
 import dotty.tools.dotc.transform.MegaPhase._
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.Context
-import scala.collection.mutable
-import dotty.tools.dotc.core.Names.Name
-import NameOps._
 import Types._
-import scala.collection.SortedSet
 import Decorators._
 import StdNames._
 import dotty.tools.dotc.util.Positions.Position
@@ -24,7 +17,7 @@ import dotty.tools.dotc.config.JavaPlatform
 class CollectEntryPoints extends MiniPhase {
 
   /** perform context-dependant initialization */
-  override def prepareForUnit(tree: tpd.Tree)(implicit ctx: Context) = {
+  override def prepareForUnit(tree: tpd.Tree)(implicit ctx: Context): Context = {
     entryPoints = collection.immutable.TreeSet.empty[Symbol](new SymbolOrdering())
     assert(ctx.platform.isInstanceOf[JavaPlatform], "Java platform specific phase")
     ctx
@@ -32,7 +25,7 @@ class CollectEntryPoints extends MiniPhase {
 
   private[this] var entryPoints: Set[Symbol] = _
 
-  def getEntryPoints = entryPoints.toList
+  def getEntryPoints: List[Symbol] = entryPoints.toList
 
   override def phaseName: String = "collectEntryPoints"
   override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context): tpd.Tree = {
diff --git a/compiler/src/dotty/tools/dotc/transform/CollectNullableFields.scala b/compiler/src/dotty/tools/dotc/transform/CollectNullableFields.scala
index 201ae4e21def..bae91bf62417 100644
--- a/compiler/src/dotty/tools/dotc/transform/CollectNullableFields.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CollectNullableFields.scala
@@ -4,17 +4,15 @@ import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Symbols.Symbol
-import dotty.tools.dotc.core.Types.{Type, ExprType}
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
 import dotty.tools.dotc.transform.SymUtils._
 
-import scala.collection.JavaConverters._
 import scala.collection.mutable
 
 import java.util.IdentityHashMap
 
 object CollectNullableFields {
-  val name = "collectNullableFields"
+  val name: String = "collectNullableFields"
 }
 
 /** Collect fields that can be nulled out after use in lazy initialization.
@@ -43,10 +41,10 @@ object CollectNullableFields {
 class CollectNullableFields extends MiniPhase {
   import tpd._
 
-  override def phaseName = CollectNullableFields.name
+  override def phaseName: String = CollectNullableFields.name
 
   /** Running after `ElimByName` to see by names as nullable types. */
-  override def runsAfter = Set(ElimByName.name)
+  override def runsAfter: Set[String] = Set(ElimByName.name)
 
   private[this] sealed trait FieldInfo
   private[this] case object NotNullable extends FieldInfo
@@ -55,7 +53,7 @@ class CollectNullableFields extends MiniPhase {
   /** Whether or not a field is nullable */
   private[this] var nullability: IdentityHashMap[Symbol, FieldInfo] = _
 
-  override def prepareForUnit(tree: Tree)(implicit ctx: Context) = {
+  override def prepareForUnit(tree: Tree)(implicit ctx: Context): Context = {
     if (nullability == null) nullability = new IdentityHashMap
     ctx
   }
@@ -90,10 +88,10 @@ class CollectNullableFields extends MiniPhase {
     tree
   }
 
-  override def transformIdent(tree: Ident)(implicit ctx: Context) =
+  override def transformIdent(tree: Ident)(implicit ctx: Context): Tree =
     recordUse(tree)
 
-  override def transformSelect(tree: Select)(implicit ctx: Context) =
+  override def transformSelect(tree: Select)(implicit ctx: Context): Tree =
     recordUse(tree)
 
   /** Map lazy values to the fields they should null after initialization. */
diff --git a/compiler/src/dotty/tools/dotc/transform/Constructors.scala b/compiler/src/dotty/tools/dotc/transform/Constructors.scala
index 89a3d16772a4..78c440061db7 100644
--- a/compiler/src/dotty/tools/dotc/transform/Constructors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Constructors.scala
@@ -6,22 +6,18 @@ import MegaPhase._
 import dotty.tools.dotc.ast.tpd._
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.StdNames._
-import Phases._
 import ast._
 import Trees._
 import Flags._
 import SymUtils._
 import Symbols._
-import SymDenotations._
-import Types._
 import Decorators._
 import DenotTransformers._
-import util.Positions._
 import Constants.Constant
 import collection.mutable
 
 object Constructors {
-  val name = "constructors"
+  val name: String = "constructors"
 }
 
 /** This transform
@@ -34,8 +30,8 @@ class Constructors extends MiniPhase with IdentityDenotTransformer { thisPhase =
   import tpd._
 
   override def phaseName: String = Constructors.name
-  override def runsAfter = Set(HoistSuperArgs.name)
-  override def runsAfterGroupsOf = Set(Memoize.name)
+  override def runsAfter: Set[String] = Set(HoistSuperArgs.name)
+  override def runsAfterGroupsOf: Set[String] = Set(Memoize.name)
     // Memoized needs to be finished because we depend on the ownerchain after Memoize
     // when checking whether an ident is an access in a constructor or outside it.
     // This test is done in the right-hand side of a value definition. If Memoize
diff --git a/compiler/src/dotty/tools/dotc/transform/CookComments.scala b/compiler/src/dotty/tools/dotc/transform/CookComments.scala
index adaf8e36976f..a78f19d878e6 100644
--- a/compiler/src/dotty/tools/dotc/transform/CookComments.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CookComments.scala
@@ -5,7 +5,7 @@ import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.typer.Docstrings
 
 class CookComments extends MegaPhase.MiniPhase {
-  override def phaseName = "cookComments"
+  override def phaseName: String = "cookComments"
 
   override def transformTypeDef(tree: tpd.TypeDef)(implicit ctx: Context): tpd.Tree = {
     if (ctx.settings.YcookComments.value && tree.isClassDef) {
diff --git a/compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala b/compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala
index a50b8cb01e97..6b07073a886e 100644
--- a/compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CrossCastAnd.scala
@@ -3,11 +3,10 @@ package dotty.tools.dotc.transform
 import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.core.Flags
-import dotty.tools.dotc.core.Types.{NoType, Type, AndType}
+import dotty.tools.dotc.core.Types.AndType
 import dotty.tools.dotc.transform.MegaPhase._
 import tpd._
 
-import scala.collection.mutable.ListBuffer
 
 
 /**
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
index ba1c572f45c6..b35704f02019 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimByName.scala
@@ -1,17 +1,11 @@
 package dotty.tools.dotc
 package transform
 
-import MegaPhase._
 import core._
 import DenotTransformers.InfoTransformer
 import Symbols._
-import SymDenotations._
 import Contexts._
 import Types._
-import Flags._
-import Decorators._
-import SymUtils._
-import util.Attachment
 import core.StdNames.nme
 import ast.Trees._
 
@@ -42,7 +36,7 @@ class ElimByName extends TransformByNameApply with InfoTransformer {
 
   override def phaseName: String = ElimByName.name
 
-  override def runsAfterGroupsOf = Set(Splitter.name)
+  override def runsAfterGroupsOf: Set[String] = Set(Splitter.name)
     // I got errors running this phase in an earlier group, but I did not track them down.
 
   override def changesParents: Boolean = true // Only true for by-names
@@ -85,5 +79,5 @@ class ElimByName extends TransformByNameApply with InfoTransformer {
 }
 
 object ElimByName {
-  val name = "elimByName"
+  val name: String = "elimByName"
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala b/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala
index a9d2ef7cff14..d9327f53d145 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimErasedValueType.scala
@@ -3,13 +3,13 @@ package transform
 
 import ast.{Trees, tpd}
 import core._, core.Decorators._
-import MegaPhase._, Phases.Phase
-import Types._, Contexts._, Constants._, Names._, NameOps._, Flags._, DenotTransformers._
-import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._, Scopes._, Denotations._
+import MegaPhase._
+import Types._, Contexts._, Flags._, DenotTransformers._
+import Symbols._, StdNames._, Trees._
 import TypeErasure.ErasedValueType, ValueClasses._
 
 object ElimErasedValueType {
-  val name = "elimErasedValueType"
+  val name: String = "elimErasedValueType"
 }
 
 /** This phase erases ErasedValueType to their underlying type.
@@ -25,7 +25,7 @@ class ElimErasedValueType extends MiniPhase with InfoTransformer {
 
   override def phaseName: String = ElimErasedValueType.name
 
-  override def runsAfter = Set(Erasure.name)
+  override def runsAfter: Set[String] = Set(Erasure.name)
 
   def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = sym match {
     case sym: ClassSymbol if sym is ModuleClass =>
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimOuterSelect.scala b/compiler/src/dotty/tools/dotc/transform/ElimOuterSelect.scala
index 7bc8c696e1a0..1814e2b282b4 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimOuterSelect.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimOuterSelect.scala
@@ -5,9 +5,7 @@ import core._
 import MegaPhase.MiniPhase
 import Contexts.Context
 import Types._
-import Decorators._
 import NameKinds.OuterSelectName
-import ast.Trees._
 
 /** This phase rewrites outer selects `E.n_<outer>` which were introduced by
  *  inlining to outer paths.
@@ -17,14 +15,14 @@ class ElimOuterSelect extends MiniPhase {
 
   override def phaseName: String = "elimOuterSelect"
 
-  override def runsAfterGroupsOf = Set(ExplicitOuter.name)
+  override def runsAfterGroupsOf: Set[String] = Set(ExplicitOuter.name)
     // ExplicitOuter needs to have run to completion before so that all classes
     // that need an outer accessor have one.
 
   /** Convert a selection of the form `qual.n_<outer>` to an outer path from `qual` of
    *  length `n`.
    */
-  override def transformSelect(tree: Select)(implicit ctx: Context) =
+  override def transformSelect(tree: Select)(implicit ctx: Context): Tree =
     tree.name match {
       case OuterSelectName(_, nhops) =>
         val SkolemType(tp) = tree.tpe
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala
index c94631e78d30..9f32ff936b64 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimRepeated.scala
@@ -2,7 +2,6 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import Names._
 import StdNames.nme
 import Types._
 import dotty.tools.dotc.transform.MegaPhase._
@@ -13,17 +12,11 @@ import Symbols._
 import Constants._
 import Decorators._
 import Denotations._, SymDenotations._
-import Decorators.StringInterpolators
 import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.core.Annotations.ConcreteAnnotation
-import scala.collection.mutable
 import DenotTransformers._
-import Names.Name
-import NameOps._
-import TypeUtils._
 
 object ElimRepeated {
-  val name = "elimRepeated"
+  val name: String = "elimRepeated"
 }
 
 /** A transformer that removes repeated parameters (T*) from all types, replacing
@@ -32,9 +25,9 @@ object ElimRepeated {
 class ElimRepeated extends MiniPhase with InfoTransformer { thisPhase =>
   import ast.tpd._
 
-  override def phaseName = ElimRepeated.name
+  override def phaseName: String = ElimRepeated.name
 
-  override def changesMembers = true // the phase adds vararg bridges
+  override def changesMembers: Boolean = true // the phase adds vararg bridges
 
   def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type =
     elimRepeated(tp)
diff --git a/compiler/src/dotty/tools/dotc/transform/ElimStaticThis.scala b/compiler/src/dotty/tools/dotc/transform/ElimStaticThis.scala
index 662e5d5c55bd..b7ac1a688be4 100644
--- a/compiler/src/dotty/tools/dotc/transform/ElimStaticThis.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ElimStaticThis.scala
@@ -5,8 +5,6 @@ import core._
 import Contexts.Context
 import Flags._
 import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.core.StdNames._
-import dotty.tools.dotc.core.SymDenotations.SymDenotation
 import MegaPhase.MiniPhase
 import dotty.tools.dotc.core.Types.{ThisType, TermRef}
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
index e95f90348e03..14a39ff9c9ee 100644
--- a/compiler/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -18,12 +18,10 @@ import core.Definitions._
 import typer.NoChecking
 import typer.Inliner
 import typer.ProtoTypes._
-import typer.ErrorReporting._
 import core.TypeErasure._
 import core.Decorators._
-import dotty.tools.dotc.ast.{Trees, tpd, untpd}
+import dotty.tools.dotc.ast.{tpd, untpd}
 import ast.Trees._
-import scala.collection.mutable.ListBuffer
 import dotty.tools.dotc.core.{Constants, Flags}
 import ValueClasses._
 import TypeUtils._
@@ -36,7 +34,7 @@ class Erasure extends Phase with DenotTransformer {
   override def phaseName: String = Erasure.name
 
   /** List of names of phases that should precede this phase */
-  override def runsAfter = Set(InterceptedMethods.name, Splitter.name, ElimRepeated.name)
+  override def runsAfter: Set[String] = Set(InterceptedMethods.name, Splitter.name, ElimRepeated.name)
 
   override def changesMembers: Boolean = true // the phase adds bridges
   override def changesParents: Boolean = true // the phase drops Any
@@ -92,14 +90,14 @@ class Erasure extends Phase with DenotTransformer {
       ref.derivedSingleDenotation(ref.symbol, transformInfo(ref.symbol, ref.symbol.info))
   }
 
-  val eraser = new Erasure.Typer(this)
+  private val eraser: Erasure.Typer = new Erasure.Typer(this)
 
   def run(implicit ctx: Context): Unit = {
     val unit = ctx.compilationUnit
     unit.tpdTree = eraser.typedExpr(unit.tpdTree)(ctx.fresh.setPhase(this.next))
   }
 
-  override def checkPostCondition(tree: tpd.Tree)(implicit ctx: Context) = {
+  override def checkPostCondition(tree: tpd.Tree)(implicit ctx: Context): Unit = {
     assertErased(tree)
     tree match {
       case res: tpd.This =>
@@ -151,19 +149,19 @@ object Erasure {
   import tpd._
   import TypeTestsCasts._
 
-  val name = "erasure"
+  val name: String = "erasure"
 
   object Boxing {
 
-    def isUnbox(sym: Symbol)(implicit ctx: Context) =
+    def isUnbox(sym: Symbol)(implicit ctx: Context): Boolean =
       sym.name == nme.unbox && sym.owner.linkedClass.isPrimitiveValueClass
 
-    def isBox(sym: Symbol)(implicit ctx: Context) =
+    def isBox(sym: Symbol)(implicit ctx: Context): Boolean =
       sym.name == nme.box && sym.owner.linkedClass.isPrimitiveValueClass
 
-    def boxMethod(cls: ClassSymbol)(implicit ctx: Context) =
+    def boxMethod(cls: ClassSymbol)(implicit ctx: Context): Symbol =
       cls.linkedClass.info.member(nme.box).symbol
-    def unboxMethod(cls: ClassSymbol)(implicit ctx: Context) =
+    def unboxMethod(cls: ClassSymbol)(implicit ctx: Context): Symbol =
       cls.linkedClass.info.member(nme.unbox).symbol
 
     /** Isf this tree is an unbox operation which can be safely removed
@@ -181,7 +179,7 @@ object Erasure {
         EmptyTree
     }
 
-    def constant(tree: Tree, const: Tree)(implicit ctx: Context) =
+    def constant(tree: Tree, const: Tree)(implicit ctx: Context): Tree =
       (if (isPureExpr(tree)) const else Block(tree :: Nil, const))
         .withPos(tree.pos)
 
@@ -328,7 +326,7 @@ object Erasure {
       tree
     }
 
-    def erasedDef(sym: Symbol)(implicit ctx: Context) = {
+    def erasedDef(sym: Symbol)(implicit ctx: Context): Thicket = {
       if (sym.owner.isClass) sym.dropAfter(erasurePhase)
       tpd.EmptyTree
     }
@@ -481,7 +479,7 @@ object Erasure {
       case _ => Nil
     }
 
-    override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(implicit ctx: Context) = {
+    override def typedTypeApply(tree: untpd.TypeApply, pt: Type)(implicit ctx: Context): Tree = {
       val ntree = interceptTypeApply(tree.asInstanceOf[TypeApply])(ctx.withPhase(ctx.erasurePhase))
 
       ntree match {
@@ -531,17 +529,17 @@ object Erasure {
     // The following four methods take as the proto-type the erasure of the pre-existing type,
     // if the original proto-type is not a value type.
     // This makes all branches be adapted to the correct type.
-    override def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(implicit ctx: Context) =
+    override def typedSeqLiteral(tree: untpd.SeqLiteral, pt: Type)(implicit ctx: Context): SeqLiteral =
       super.typedSeqLiteral(tree, erasure(tree.typeOpt))
         // proto type of typed seq literal is original type;
 
-    override def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context) =
+    override def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context): Tree =
       super.typedIf(tree, adaptProto(tree, pt))
 
-    override def typedMatch(tree: untpd.Match, pt: Type)(implicit ctx: Context) =
+    override def typedMatch(tree: untpd.Match, pt: Type)(implicit ctx: Context): Tree =
       super.typedMatch(tree, adaptProto(tree, pt))
 
-    override def typedTry(tree: untpd.Try, pt: Type)(implicit ctx: Context) =
+    override def typedTry(tree: untpd.Try, pt: Type)(implicit ctx: Context): Try =
       super.typedTry(tree, adaptProto(tree, pt))
 
     private def adaptProto(tree: untpd.Tree, pt: Type)(implicit ctx: Context) = {
@@ -599,7 +597,7 @@ object Erasure {
         super.typedDefDef(ddef1, sym)
       }
 
-    override def typedClosure(tree: untpd.Closure, pt: Type)(implicit ctx: Context) = {
+    override def typedClosure(tree: untpd.Closure, pt: Type)(implicit ctx: Context): Tree = {
       val xxl = defn.isXXLFunctionClass(tree.typeOpt.typeSymbol)
       var implClosure @ Closure(_, meth, _) = super.typedClosure(tree, pt)
       if (xxl) implClosure = cpy.Closure(implClosure)(tpt = TypeTree(defn.FunctionXXLType))
diff --git a/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala b/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala
index 5a4084012945..6d945ef05f48 100644
--- a/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ExpandPrivate.scala
@@ -2,24 +2,18 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.core.DenotTransformers.{IdentityDenotTransformer, SymTransformer}
+import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
 import Contexts.Context
 import Symbols._
-import Scopes._
 import Flags._
-import StdNames._
 import SymDenotations._
-import Types._
 
-import collection.mutable
 import Decorators._
 import ast.Trees._
 import MegaPhase._
 import java.io.File.separatorChar
 
 import ValueClasses._
-import dotty.tools.dotc.core.Phases.Phase
 
 /** Make private term members that are accessed from another class
  *  non-private by resetting the Private flag and expanding their name.
@@ -41,9 +35,9 @@ class ExpandPrivate extends MiniPhase with IdentityDenotTransformer { thisPhase
   override def phaseName: String = "expandPrivate"
 
   // This phase moves methods around (in infotransform) so it may need to make other methods public
-  override def runsAfter = Set(MoveStatics.name)
+  override def runsAfter: Set[String] = Set(MoveStatics.name)
 
-  override def changesMembers = true // the phase introduces new members with mangled names
+  override def changesMembers: Boolean = true // the phase introduces new members with mangled names
 
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
     tree match {
@@ -96,17 +90,17 @@ class ExpandPrivate extends MiniPhase with IdentityDenotTransformer { thisPhase
       d.ensureNotPrivate.installAfter(thisPhase)
     }
 
-  override def transformIdent(tree: Ident)(implicit ctx: Context) = {
+  override def transformIdent(tree: Ident)(implicit ctx: Context): Ident = {
     ensurePrivateAccessible(tree.symbol)
     tree
   }
 
-  override def transformSelect(tree: Select)(implicit ctx: Context) = {
+  override def transformSelect(tree: Select)(implicit ctx: Context): Select = {
     ensurePrivateAccessible(tree.symbol)
     tree
   }
 
-  override def transformDefDef(tree: DefDef)(implicit ctx: Context) = {
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context): DefDef = {
     val sym = tree.symbol
     tree.rhs match {
       case Apply(sel @ Select(_: Super, _), _)
diff --git a/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala b/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala
index 3cac673ae5b0..8e207d31ef5f 100644
--- a/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ExpandSAMs.scala
@@ -3,10 +3,8 @@ package transform
 
 import core._
 import Contexts._, Symbols._, Types._, Flags._, Decorators._, StdNames._, Constants._
-import SymDenotations.SymDenotation
 import MegaPhase._
 import SymUtils._
-import ast.untpd
 import ast.Trees._
 import dotty.tools.dotc.reporting.diagnostic.messages.TypeMismatch
 import dotty.tools.dotc.util.Positions.Position
@@ -25,7 +23,7 @@ import dotty.tools.dotc.util.Positions.Position
  *  However, implicit function types do not count as SAM types.
  */
 class ExpandSAMs extends MiniPhase {
-  override def phaseName = "expandSAMs"
+  override def phaseName: String = "expandSAMs"
 
   import ast.tpd._
 
diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
index fead31d29dd8..6a7e041e690a 100644
--- a/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ExplicitOuter.scala
@@ -14,7 +14,6 @@ import core.NameOps._
 import ast.Trees._
 import SymUtils._
 import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.core.Phases.Phase
 
 import collection.mutable
 import scala.annotation.tailrec
@@ -42,12 +41,12 @@ class ExplicitOuter extends MiniPhase with InfoTransformer { thisPhase =>
   /** List of names of phases that should have finished their processing of all compilation units
     * before this phase starts
     */
-  override def runsAfter = Set(PatternMatcher.name, HoistSuperArgs.name)
+  override def runsAfter: Set[String] = Set(PatternMatcher.name, HoistSuperArgs.name)
 
-  override def changesMembers = true // the phase adds outer accessors
+  override def changesMembers: Boolean = true // the phase adds outer accessors
 
   /** Add outer accessors if a class always needs an outer pointer */
-  override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context) = tp match {
+  override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = tp match {
     case tp @ ClassInfo(_, cls, _, decls, _) if needsOuterAlways(cls) =>
       val newDecls = decls.cloneScope
       newOuterAccessors(cls).foreach(newDecls.enter)
@@ -128,7 +127,7 @@ class ExplicitOuter extends MiniPhase with InfoTransformer { thisPhase =>
 object ExplicitOuter {
   import ast.tpd._
 
-  val name = "explicitOuter"
+  val name: String = "explicitOuter"
 
   /** Ensure that class `cls` has outer accessors */
   def ensureOuterAccessors(cls: ClassSymbol)(implicit ctx: Context): Unit =
diff --git a/compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala b/compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala
index 307b8ea56854..7ab625ce2a17 100644
--- a/compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ExplicitSelf.scala
@@ -5,9 +5,7 @@ import core._
 import Contexts.Context
 import Types._
 import MegaPhase._
-import Decorators._
 import ast.Trees._
-import Flags._
 
 /** Transform references of the form
  *
@@ -26,9 +24,9 @@ import Flags._
 class ExplicitSelf extends MiniPhase {
   import ast.tpd._
 
-  override def phaseName = "explicitSelf"
+  override def phaseName: String = "explicitSelf"
 
-  override def transformIdent(tree: Ident)(implicit ctx: Context) = tree.tpe match {
+  override def transformIdent(tree: Ident)(implicit ctx: Context): Tree = tree.tpe match {
     case tp: ThisType =>
       ctx.debuglog(s"owner = ${ctx.owner}, context = ${ctx}")
       This(tp.cls) withPos tree.pos
diff --git a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala
index 02d072bf6a86..753baad697ce 100644
--- a/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ExtensionMethods.scala
@@ -7,18 +7,14 @@ package transform
 
 import dotty.tools.dotc.transform.MegaPhase._
 import ValueClasses._
-import dotty.tools.dotc.ast.{Trees, tpd}
-import scala.collection.{ mutable, immutable }
+import dotty.tools.dotc.ast.tpd
+import scala.collection.mutable
 import core._
-import dotty.tools.dotc.core.Phases.Phase
-import Types._, Contexts._, Constants._, Names._, NameOps._, Flags._, DenotTransformers._
-import SymDenotations._, Symbols._, StdNames._, Annotations._, Trees._, Scopes._, Denotations._
+import Types._, Contexts._, Names._, Flags._, DenotTransformers._
+import SymDenotations._, Symbols._, StdNames._, Denotations._
 import TypeErasure.{ valueErasure, ErasedValueType }
-import TypeUtils._
 import NameKinds.{ExtMethName, UniqueExtMethName}
-import util.Positions._
 import Decorators._
-import SymUtils._
 
 /**
  * Perform Step 1 in the inline classes SIP: Creates extension methods for all
@@ -47,14 +43,14 @@ class ExtensionMethods extends MiniPhase with DenotTransformer with FullParamete
   /** the following two members override abstract members in Transform */
   override def phaseName: String = ExtensionMethods.name
 
-  override def runsAfter = Set(
+  override def runsAfter: Set[String] = Set(
     ElimRepeated.name,
     ProtectedAccessors.name,  // protected accessors cannot handle code that is moved from class to companion object
   )
 
-  override def runsAfterGroupsOf = Set(FirstTransform.name) // need companion objects to exist
+  override def runsAfterGroupsOf: Set[String] = Set(FirstTransform.name) // need companion objects to exist
 
-  override def changesMembers = true // the phase adds extension methods
+  override def changesMembers: Boolean = true // the phase adds extension methods
 
   override def transform(ref: SingleDenotation)(implicit ctx: Context): SingleDenotation = ref match {
     case moduleClassSym: ClassDenotation if moduleClassSym is ModuleClass =>
@@ -173,7 +169,7 @@ class ExtensionMethods extends MiniPhase with DenotTransformer with FullParamete
 }
 
 object ExtensionMethods {
-  val name = "extmethods"
+  val name: String = "extmethods"
 
   /** Generate stream of possible names for the extension version of given instance method `imeth`.
    *  If the method is not overloaded, this stream consists of just "imeth$extension".
diff --git a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
index 27eabbaea25d..de660a9df6ec 100644
--- a/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
+++ b/compiler/src/dotty/tools/dotc/transform/FirstTransform.scala
@@ -3,7 +3,6 @@ package transform
 
 import core._
 import Names._
-import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.transform.MegaPhase._
 import ast.Trees._
 import ast.untpd
@@ -12,19 +11,15 @@ import Types._
 import Constants.Constant
 import Contexts.Context
 import Symbols._
-import SymDenotations._
 import Decorators._
-import dotty.tools.dotc.core.Annotations.ConcreteAnnotation
-import dotty.tools.dotc.core.Denotations.SingleDenotation
 import scala.collection.mutable
 import DenotTransformers._
-import typer.Checking
 import NameOps._
-import NameKinds.{AvoidClashName, OuterSelectName}
+import NameKinds.OuterSelectName
 import StdNames._
 
 object FirstTransform {
-  val name = "firstTransform"
+  val name: String = "firstTransform"
 }
 
 
@@ -41,7 +36,7 @@ object FirstTransform {
 class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
   import ast.tpd._
 
-  override def phaseName = FirstTransform.name
+  override def phaseName: String = FirstTransform.name
 
   /** eliminate self symbol in ClassInfo */
   override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = tp match {
@@ -108,7 +103,7 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
     cpy.Template(impl)(self = EmptyValDef)
   }
 
-  override def transformDefDef(ddef: DefDef)(implicit ctx: Context) = {
+  override def transformDefDef(ddef: DefDef)(implicit ctx: Context): Tree = {
     val meth = ddef.symbol.asTerm
     if (meth.hasAnnotation(defn.NativeAnnot)) {
       meth.resetFlag(Deferred)
@@ -143,31 +138,31 @@ class FirstTransform extends MiniPhase with InfoTransformer { thisPhase =>
     (result /: binders)(Annotated(_, _))
   }
 
-  override def transformOther(tree: Tree)(implicit ctx: Context) = tree match {
+  override def transformOther(tree: Tree)(implicit ctx: Context): Tree = tree match {
     case tree: Import => EmptyTree
     case tree: NamedArg => transformAllDeep(tree.arg)
     case tree => if (tree.isType) toTypeTree(tree) else tree
   }
 
-  override def transformIdent(tree: Ident)(implicit ctx: Context) =
+  override def transformIdent(tree: Ident)(implicit ctx: Context): Tree =
     if (tree.isType) toTypeTree(tree) else constToLiteral(tree)
 
-  override def transformSelect(tree: Select)(implicit ctx: Context) =
+  override def transformSelect(tree: Select)(implicit ctx: Context): Tree =
     if (tree.isType) toTypeTree(tree) else constToLiteral(tree)
 
-  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context) =
+  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context): Tree =
     constToLiteral(tree)
 
-  override def transformApply(tree: Apply)(implicit ctx: Context) =
+  override def transformApply(tree: Apply)(implicit ctx: Context): Tree =
     constToLiteral(foldCondition(tree))
 
-  override def transformTyped(tree: Typed)(implicit ctx: Context) =
+  override def transformTyped(tree: Typed)(implicit ctx: Context): Tree =
     constToLiteral(tree)
 
-  override def transformBlock(tree: Block)(implicit ctx: Context) =
+  override def transformBlock(tree: Block)(implicit ctx: Context): Tree =
     constToLiteral(tree)
 
-  override def transformIf(tree: If)(implicit ctx: Context) =
+  override def transformIf(tree: If)(implicit ctx: Context): Tree =
     tree.cond match {
       case Literal(Constant(c: Boolean)) => if (c) tree.thenp else tree.elsep
       case _ => tree
diff --git a/compiler/src/dotty/tools/dotc/transform/Flatten.scala b/compiler/src/dotty/tools/dotc/transform/Flatten.scala
index 065c982c2eaa..afbb854f542b 100644
--- a/compiler/src/dotty/tools/dotc/transform/Flatten.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Flatten.scala
@@ -3,7 +3,6 @@ package transform
 
 import core._
 import DenotTransformers.SymTransformer
-import Phases.Phase
 import Contexts.{Context, FreshContext}
 import Flags._
 import SymDenotations.SymDenotation
@@ -15,21 +14,21 @@ import util.Store
 class Flatten extends MiniPhase with SymTransformer {
   import ast.tpd._
 
-  override def phaseName = "flatten"
+  override def phaseName: String = "flatten"
 
   // private[this] and protected[this] modifiers must be dropped
   // before classes are lifted. Getters drop these modifiers.
-  override def runsAfter = Set(Getters.name)
+  override def runsAfter: Set[String] = Set(Getters.name)
 
-  override def changesMembers = true // the phase removes inner classes
+  override def changesMembers: Boolean = true // the phase removes inner classes
 
   private var LiftedDefs: Store.Location[mutable.ListBuffer[Tree]] = _
   private def liftedDefs(implicit ctx: Context) = ctx.store(LiftedDefs)
 
-  override def initContext(ctx: FreshContext) =
+  override def initContext(ctx: FreshContext): Unit =
     LiftedDefs = ctx.addLocation[mutable.ListBuffer[Tree]](null)
 
-  def transformSym(ref: SymDenotation)(implicit ctx: Context) = {
+  def transformSym(ref: SymDenotation)(implicit ctx: Context): SymDenotation = {
     if (ref.isClass && !ref.is(Package) && !ref.owner.is(Package)) {
       ref.copySymDenotation(
         name = ref.flatName,
@@ -38,7 +37,7 @@ class Flatten extends MiniPhase with SymTransformer {
     else ref
   }
 
-  override def prepareForPackageDef(tree: PackageDef)(implicit ctx: Context) =
+  override def prepareForPackageDef(tree: PackageDef)(implicit ctx: Context): FreshContext =
     ctx.fresh.updateStore(LiftedDefs, new mutable.ListBuffer[Tree])
 
   private def liftIfNested(tree: Tree)(implicit ctx: Context) =
@@ -48,7 +47,7 @@ class Flatten extends MiniPhase with SymTransformer {
       EmptyTree
     }
 
-  override def transformStats(stats: List[Tree])(implicit ctx: Context) =
+  override def transformStats(stats: List[Tree])(implicit ctx: Context): List[Tree] =
     if (ctx.owner is Package) {
       val liftedStats = stats ++ liftedDefs
       liftedDefs.clear()
@@ -56,6 +55,6 @@ class Flatten extends MiniPhase with SymTransformer {
     }
     else stats
 
-  override def transformTypeDef(tree: TypeDef)(implicit ctx: Context) =
+  override def transformTypeDef(tree: TypeDef)(implicit ctx: Context): Tree =
     liftIfNested(tree)
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala b/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala
index b636b8476fa4..bbad627150d4 100644
--- a/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala
+++ b/compiler/src/dotty/tools/dotc/transform/FullParameterization.scala
@@ -52,7 +52,6 @@ import ast.Trees._
 trait FullParameterization {
 
   import tpd._
-  import FullParameterization._
 
   /** If references to original symbol `referenced` from within fully parameterized method
    *  `derived` should be rewired to some fully parameterized method, the rewiring target symbol,
diff --git a/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala b/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala
index 2912d5a1391c..e0720aab5a47 100644
--- a/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala
+++ b/compiler/src/dotty/tools/dotc/transform/FunctionalInterfaces.scala
@@ -1,26 +1,18 @@
 package dotty.tools.dotc
 package transform
 
+import core._
 import MegaPhase._
-import core.DenotTransformers._
-import core.Symbols._
-import core.Contexts._
-import core.Types._
-import core.Flags._
-import core.Decorators._
-import core.SymDenotations._
-import core.StdNames.nme
-import core.Names._
-import core.NameOps._
-import ast.Trees._
-import SymUtils._
+import Names._
+import Symbols._
+import Contexts._
+import Decorators._
+import NameOps._
 import dotty.tools.dotc.ast.tpd
-import collection.{ mutable, immutable }
-import collection.mutable.{ LinkedHashMap, LinkedHashSet, TreeSet }
 
 
 object FunctionalInterfaces {
-  val name = "functionalInterfaces"
+  val name: String = "functionalInterfaces"
 }
 
 /**
@@ -31,8 +23,8 @@ class FunctionalInterfaces extends MiniPhase {
 
   def phaseName: String = FunctionalInterfaces.name
 
-  val functionName = "JFunction".toTermName
-  val functionPackage = "scala.compat.java8.".toTermName
+  private val functionName: TermName = "JFunction".toTermName
+  private val functionPackage: TermName = "scala.compat.java8.".toTermName
 
   override def transformClosure(tree: Closure)(implicit ctx: Context): Tree = {
     val cls = tree.tpe.widen.classSymbol.asClass
diff --git a/compiler/src/dotty/tools/dotc/transform/GetClass.scala b/compiler/src/dotty/tools/dotc/transform/GetClass.scala
index ef3f7b6e5ca3..60e47d077aa0 100644
--- a/compiler/src/dotty/tools/dotc/transform/GetClass.scala
+++ b/compiler/src/dotty/tools/dotc/transform/GetClass.scala
@@ -4,7 +4,6 @@ package transform
 import ast.tpd
 import core.Contexts.Context
 import core.StdNames.nme
-import core.Phases.Phase
 import TypeUtils._
 import MegaPhase.MiniPhase
 
@@ -21,7 +20,7 @@ class GetClass extends MiniPhase {
   override def phaseName: String = "getClass"
 
   // getClass transformation should be applied to specialized methods
-  override def runsAfter = Set(Erasure.name, FunctionalInterfaces.name)
+  override def runsAfter: Set[String] = Set(Erasure.name, FunctionalInterfaces.name)
 
   override def transformApply(tree: Apply)(implicit ctx: Context): Tree = {
     import ast.Trees._
diff --git a/compiler/src/dotty/tools/dotc/transform/Getters.scala b/compiler/src/dotty/tools/dotc/transform/Getters.scala
index 3010ac20e308..60658f9bc460 100644
--- a/compiler/src/dotty/tools/dotc/transform/Getters.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Getters.scala
@@ -7,11 +7,8 @@ import Contexts.Context
 import SymDenotations.SymDenotation
 import Types._
 import Symbols._
-import SymUtils._
-import Constants._
 import MegaPhase._
 import Flags._
-import Decorators._
 import ValueClasses._
 
 /** Performs the following rewritings for fields of a class:
@@ -52,7 +49,7 @@ import ValueClasses._
 class Getters extends MiniPhase with SymTransformer {
   import ast.tpd._
 
-  override def phaseName = Getters.name
+  override def phaseName: String = Getters.name
 
   override def transformSym(d: SymDenotation)(implicit ctx: Context): SymDenotation = {
     def noGetterNeeded =
@@ -88,5 +85,5 @@ class Getters extends MiniPhase with SymTransformer {
 }
 
 object Getters {
-  val name = "getters"
+  val name: String = "getters"
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala b/compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala
index d6d8377a4252..302d2330d056 100644
--- a/compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala
+++ b/compiler/src/dotty/tools/dotc/transform/HoistSuperArgs.scala
@@ -11,12 +11,11 @@ import core.Flags._
 import core.Decorators._
 import collection.mutable
 import ast.Trees._
-import core.Names.TermName
 import core.NameKinds.SuperArgName
 import SymUtils._
 
 object HoistSuperArgs {
-  val name = "hoistSuperArgs"
+  val name: String = "hoistSuperArgs"
 }
 
 /** This phase hoists complex arguments of supercalls and this-calls out of the enclosing class.
@@ -44,9 +43,9 @@ object HoistSuperArgs {
 class HoistSuperArgs extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   import ast.tpd._
 
-  def phaseName = HoistSuperArgs.name
+  def phaseName: String = HoistSuperArgs.name
 
-  override def runsAfter = Set(ByNameClosures.name)
+  override def runsAfter: Set[String] = Set(ByNameClosures.name)
     // By name closures need to be introduced first in order to be hoisted out here.
     // There's an interaction with by name closures in that the <cbn-arg> marker
     // application should not be hoisted, but be left at the point of call.
@@ -56,7 +55,7 @@ class HoistSuperArgs extends MiniPhase with IdentityDenotTransformer { thisPhase
    *  Hoisted superarg methods are collected in `superArgDefs`
    */
   class Hoister(cls: Symbol)(implicit ctx: Context) {
-    val superArgDefs = new mutable.ListBuffer[DefDef]
+    val superArgDefs: mutable.ListBuffer[DefDef] = new mutable.ListBuffer
 
     /** If argument is complex, hoist it out into its own method and refer to the
      *  method instead.
diff --git a/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala b/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala
index fa39295c1652..2eacd1b010e1 100644
--- a/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala
+++ b/compiler/src/dotty/tools/dotc/transform/InterceptedMethods.scala
@@ -12,7 +12,7 @@ import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
 
 object InterceptedMethods {
-  val name = "intercepted"
+  val name: String = "intercepted"
 }
 
 /** Replace member references as follows:
diff --git a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala
index ebabdf124e7e..a0093c8635ce 100644
--- a/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LambdaLift.scala
@@ -8,18 +8,16 @@ import core.Contexts._
 import core.Types._
 import core.Flags._
 import core.Decorators._
-import core.StdNames.{nme, str}
+import core.StdNames.nme
 import core.Names._
 import core.NameOps._
 import core.NameKinds.ExpandPrefixName
-import core.Phases._
 import ast.Trees._
 import SymUtils._
 import ExplicitOuter.outer
 import util.Store
-import util.Positions._
-import collection.{ mutable, immutable }
-import collection.mutable.{ HashMap, HashSet, LinkedHashMap, LinkedHashSet, TreeSet }
+import collection.mutable
+import collection.mutable.{ HashMap, HashSet, LinkedHashMap, TreeSet }
 
 object LambdaLift {
   import ast.tpd._
@@ -31,7 +29,7 @@ object LambdaLift {
     private type SymSet = TreeSet[Symbol]
 
     /** A map storing free variables of functions and classes */
-    val free = new LinkedHashMap[Symbol, SymSet]
+    val free: mutable.LinkedHashMap[Symbol, SymSet] = new LinkedHashMap
 
     /** A map storing the free variable proxies of functions and classes.
      *  For every function and class, this is a map from the free variables
@@ -58,7 +56,7 @@ object LambdaLift {
     private val outerParam = new HashMap[Symbol, Symbol]
 
     /** Buffers for lifted out classes and methods, indexed by owner */
-    val liftedDefs = new HashMap[Symbol, mutable.ListBuffer[Tree]]
+    val liftedDefs: mutable.HashMap[Symbol, mutable.ListBuffer[Tree]] = new HashMap
 
     /** A flag to indicate whether new free variables have been found */
     private[this] var changedFreeVars: Boolean = _
@@ -77,7 +75,7 @@ object LambdaLift {
       case None => Nil
     }
 
-    def proxyOf(sym: Symbol, fv: Symbol) = proxyMap.getOrElse(sym, Map.empty)(fv)
+    def proxyOf(sym: Symbol, fv: Symbol): Symbol = proxyMap.getOrElse(sym, Map.empty)(fv)
 
     def proxies(sym: Symbol): List[Symbol] =  freeVars(sym).map(proxyOf(sym, _))
 
@@ -371,7 +369,7 @@ object LambdaLift {
       liftLocals()(ctx.withPhase(thisPhase.next))
     }
 
-    def currentEnclosure(implicit ctx: Context) =
+    def currentEnclosure(implicit ctx: Context): Symbol =
       ctx.owner.enclosingMethodOrClass
 
     private def inCurrentOwner(sym: Symbol)(implicit ctx: Context) =
@@ -418,7 +416,7 @@ object LambdaLift {
       thisPhase.transformFollowingDeep(if (psym.owner.isTerm) ref(psym) else memberRef(psym))
     }
 
-    def addFreeArgs(sym: Symbol, args: List[Tree])(implicit ctx: Context) =
+    def addFreeArgs(sym: Symbol, args: List[Tree])(implicit ctx: Context): List[Tree] =
       free get sym match {
         case Some(fvs) => fvs.toList.map(proxyRef(_)) ++ args
         case _ => args
@@ -460,7 +458,7 @@ object LambdaLift {
       EmptyTree
     }
 
-    def needsLifting(sym: Symbol) = liftedOwner contains sym
+    def needsLifting(sym: Symbol): Boolean = liftedOwner contains sym
   }
 }
 
@@ -502,10 +500,10 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   /** the following two members override abstract members in Transform */
   val phaseName: String = "lambdaLift"
 
-  override def relaxedTypingInGroup = true
+  override def relaxedTypingInGroup: Boolean = true
     // Because it adds free vars as additional proxy parameters
 
-  override def runsAfterGroupsOf = Set(Constructors.name, HoistSuperArgs.name)
+  override def runsAfterGroupsOf: Set[String] = Set(Constructors.name, HoistSuperArgs.name)
     // Constructors has to happen before LambdaLift because the lambda lift logic
     // becomes simpler if it can assume that parameter accessors have already been
     // converted to parameters in super calls. Without this it is very hard to get
@@ -515,13 +513,13 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   private var Lifter: Store.Location[Lifter] = _
   private def lifter(implicit ctx: Context) = ctx.store(Lifter)
 
-  override def initContext(ctx: FreshContext) =
+  override def initContext(ctx: FreshContext): Unit =
     Lifter = ctx.addLocation[Lifter]()
 
-  override def prepareForUnit(tree: Tree)(implicit ctx: Context) =
+  override def prepareForUnit(tree: Tree)(implicit ctx: Context): Context =
     ctx.fresh.updateStore(Lifter, new Lifter(thisPhase))
 
-  override def transformIdent(tree: Ident)(implicit ctx: Context) = {
+  override def transformIdent(tree: Ident)(implicit ctx: Context): Tree = {
     val sym = tree.symbol
     tree.tpe match {
       case tpe @ TermRef(prefix, _) =>
@@ -540,13 +538,13 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisPhase =>
     }
   }
 
-  override def transformApply(tree: Apply)(implicit ctx: Context) =
+  override def transformApply(tree: Apply)(implicit ctx: Context): Apply =
     cpy.Apply(tree)(tree.fun, lifter.addFreeArgs(tree.symbol, tree.args)).withPos(tree.pos)
 
-  override def transformClosure(tree: Closure)(implicit ctx: Context) =
+  override def transformClosure(tree: Closure)(implicit ctx: Context): Closure =
     cpy.Closure(tree)(env = lifter.addFreeArgs(tree.meth.symbol, tree.env))
 
-  override def transformDefDef(tree: DefDef)(implicit ctx: Context) = {
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree = {
     val sym = tree.symbol
     val lft = lifter
     val paramsAdded =
@@ -556,20 +554,20 @@ class LambdaLift extends MiniPhase with IdentityDenotTransformer { thisPhase =>
     else paramsAdded
   }
 
-  override def transformReturn(tree: Return)(implicit ctx: Context) = tree.expr match {
+  override def transformReturn(tree: Return)(implicit ctx: Context): Tree = tree.expr match {
     case Block(stats, value) =>
       Block(stats, Return(value, tree.from)).withPos(tree.pos)
     case _ =>
       tree
   }
 
-  override def transformTemplate(tree: Template)(implicit ctx: Context) = {
+  override def transformTemplate(tree: Template)(implicit ctx: Context): Template = {
     val cls = ctx.owner
     val lft = lifter
     val impl = lft.addFreeParams(tree, lft.proxies(cls)).asInstanceOf[Template]
     cpy.Template(impl)(body = impl.body ++ lft.liftedDefs.remove(cls).get)
   }
 
-  override def transformTypeDef(tree: TypeDef)(implicit ctx: Context) =
+  override def transformTypeDef(tree: TypeDef)(implicit ctx: Context): Tree =
     if (lifter.needsLifting(tree.symbol)) lifter.liftDef(tree) else tree
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
index 3be21d41e716..0ac46fffc868 100644
--- a/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LazyVals.scala
@@ -8,22 +8,16 @@ import core._
 import Contexts._
 import Symbols._
 import Decorators._
-import NameOps._
 import NameKinds._
+import Types._
+import Flags.FlagSet
 import StdNames.nme
-import rewrites.Rewrites.patch
-import util.Positions.Position
 import dotty.tools.dotc.transform.MegaPhase._
-import dotty.tools.dotc.ast.Trees._
-import dotty.tools.dotc.ast.{untpd, tpd}
+import dotty.tools.dotc.ast.tpd
 import dotty.tools.dotc.core.Constants.Constant
-import dotty.tools.dotc.core.Types.{ExprType, NoType, MethodType}
-import dotty.tools.dotc.core.Names.Name
+import dotty.tools.dotc.core.Types.MethodType
 import SymUtils._
-import scala.collection.mutable.ListBuffer
-import dotty.tools.dotc.core.Denotations.SingleDenotation
-import dotty.tools.dotc.core.SymDenotations.SymDenotation
-import dotty.tools.dotc.core.DenotTransformers.{SymTransformer, IdentityDenotTransformer, DenotTransformer}
+import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
 import Erasure.Boxing.adaptToType
 
 import java.util.IdentityHashMap
@@ -35,22 +29,22 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
   /** this map contains mutable state of transformation: OffsetDefs to be appended to companion object definitions,
     * and number of bits currently used */
   class OffsetInfo(var defs: List[Tree], var ord:Int)
-  val appendOffsetDefs = mutable.Map.empty[Symbol, OffsetInfo]
+  private[this] val appendOffsetDefs: mutable.Map[Symbol, OffsetInfo] = mutable.Map.empty[Symbol, OffsetInfo]
 
   override def phaseName: String = "lazyVals"
 
   /** List of names of phases that should have finished processing of tree
     * before this phase starts processing same tree */
-  override def runsAfter = Set(Mixin.name, CollectNullableFields.name)
+  override def runsAfter: Set[String] = Set(Mixin.name, CollectNullableFields.name)
 
-  override def changesMembers = true  // the phase adds lazy val accessors
+  override def changesMembers: Boolean = true  // the phase adds lazy val accessors
 
-  def transformer = new LazyVals
+  def transformer: LazyVals = new LazyVals
 
-  val containerFlags = Flags.Synthetic | Flags.Mutable | Flags.Lazy
-  val initFlags      = Flags.Synthetic | Flags.Method
+  val containerFlags: FlagSet = Flags.Synthetic | Flags.Mutable | Flags.Lazy
+  val initFlags: FlagSet      = Flags.Synthetic | Flags.Method
 
-  val containerFlagsMask = Flags.Method | Flags.Lazy | Flags.Accessor | Flags.Module
+  val containerFlagsMask: FlagSet = Flags.Method | Flags.Lazy | Flags.Accessor | Flags.Module
 
   /** A map of lazy values to the fields they should null after initialization. */
   private[this] var lazyValNullables: IdentityHashMap[Symbol, mutable.ListBuffer[Symbol]] = _
@@ -62,17 +56,17 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
   }
 
 
-  override def prepareForUnit(tree: Tree)(implicit ctx: Context) = {
+  override def prepareForUnit(tree: Tree)(implicit ctx: Context): Context = {
     if (lazyValNullables == null)
       lazyValNullables = ctx.base.collectNullableFieldsPhase.asInstanceOf[CollectNullableFields].lazyValNullables
     ctx
   }
 
-  override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context): tpd.Tree =
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree =
    transformLazyVal(tree)
 
 
-  override def transformValDef(tree: tpd.ValDef)(implicit ctx: Context): tpd.Tree = {
+  override def transformValDef(tree: ValDef)(implicit ctx: Context): Tree = {
     transformLazyVal(tree)
   }
 
@@ -105,7 +99,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
 
   /** Append offset fields to companion objects
     */
-  override def transformTemplate(template: tpd.Template)(implicit ctx: Context): tpd.Tree = {
+  override def transformTemplate(template: Template)(implicit ctx: Context): Tree = {
     val cls = ctx.owner.asClass
 
     appendOffsetDefs.get(cls) match {
@@ -126,7 +120,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     * Eager val ensures thread safety and has less code generated.
     *
     */
-  def transformSyntheticModule(tree: ValOrDefDef)(implicit ctx: Context) = {
+  def transformSyntheticModule(tree: ValOrDefDef)(implicit ctx: Context): Thicket = {
     val sym = tree.symbol
     val holderSymbol = ctx.newSymbol(sym.owner, LazyLocalName.fresh(sym.asTerm.name),
       Flags.Synthetic, sym.info.widen.resultType).enteredAfter(this)
@@ -139,7 +133,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     * with a LazyHolder from
     * dotty.runtime(eg dotty.runtime.LazyInt)
     */
-  def transformLocalDef(x: ValOrDefDef)(implicit ctx: Context) = {
+  def transformLocalDef(x: ValOrDefDef)(implicit ctx: Context): Thicket = {
       val valueInitter = x.rhs
       val xname = x.name.asTermName
       val holderName = LazyLocalName.fresh(xname)
@@ -182,7 +176,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
   }
 
 
-  override def transformStats(trees: List[tpd.Tree])(implicit ctx: Context): List[tpd.Tree] = {
+  override def transformStats(trees: List[tpd.Tree])(implicit ctx: Context): List[Tree] = {
     // backend requires field usage to be after field definition
     // need to bring containers to start of method
     val (holders, stats) =
@@ -217,7 +211,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     * }
     * ```
     */
-  def mkNonThreadSafeDef(target: Tree, flag: Tree, rhs: Tree, nullables: List[Symbol])(implicit ctx: Context) = {
+  def mkNonThreadSafeDef(target: Tree, flag: Tree, rhs: Tree, nullables: List[Symbol])(implicit ctx: Context): If = {
     val stats = new mutable.ListBuffer[Tree]
     if (!isWildcardArg(rhs)) stats += target.becomes(rhs)
     stats += flag.becomes(Literal(Constant(true))) ++= nullOut(nullables)
@@ -235,7 +229,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     * }
     * ```
     */
-  def mkDefNonThreadSafeNonNullable(target: Symbol, rhs: Tree, nullables: List[Symbol])(implicit ctx: Context) = {
+  def mkDefNonThreadSafeNonNullable(target: Symbol, rhs: Tree, nullables: List[Symbol])(implicit ctx: Context): If = {
     val cond = ref(target).select(nme.eq).appliedTo(Literal(Constant(null)))
     val exp = ref(target)
     val setTarget = exp.becomes(rhs)
@@ -244,7 +238,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     If(cond, init, exp)
   }
 
-  def transformMemberDefNonVolatile(x: ValOrDefDef)(implicit ctx: Context) = {
+  def transformMemberDefNonVolatile(x: ValOrDefDef)(implicit ctx: Context): Thicket = {
     val claz = x.symbol.owner.asClass
     val tpe = x.tpe.widen.resultType.widen
     assert(!(x.symbol is Flags.Mutable))
@@ -307,14 +301,14 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
                       ord: Int,
                       target: Symbol,
                       rhs: Tree,
-                      tp: Types.Type,
+                      tp: Type,
                       offset: Tree,
                       getFlag: Tree,
                       stateMask: Tree,
                       casFlag: Tree,
                       setFlagState: Tree,
                       waitOnLock: Tree,
-                      nullables: List[Symbol])(implicit ctx: Context) = {
+                      nullables: List[Symbol])(implicit ctx: Context): DefDef = {
     val initState = Literal(Constant(0))
     val computeState = Literal(Constant(1))
     val notifyState = Literal(Constant(2))
@@ -382,7 +376,7 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
     DefDef(methodSymbol, Block(resultDef :: retryDef :: flagDef :: cycle :: setNullables, ref(resultSymbol)))
   }
 
-  def transformMemberDefVolatile(x: ValOrDefDef)(implicit ctx: Context) = {
+  def transformMemberDefVolatile(x: ValOrDefDef)(implicit ctx: Context): Thicket = {
     assert(!(x.symbol is Flags.Mutable))
 
     val tpe = x.tpe.widen.resultType.widen
@@ -450,20 +444,21 @@ class LazyVals extends MiniPhase with IdentityDenotTransformer {
 
 object LazyVals {
   object lazyNme {
+    import Names.TermName
     object RLazyVals {
-      import dotty.runtime.LazyVals._
-      val get               = Names.get.toTermName
-      val setFlag           = Names.setFlag.toTermName
-      val wait4Notification = Names.wait4Notification.toTermName
-      val state             = Names.state.toTermName
-      val cas               = Names.cas.toTermName
-      val getOffset         = Names.getOffset.toTermName
+      import dotty.runtime.LazyVals.{Names => N}
+      val get: TermName               = N.get.toTermName
+      val setFlag: TermName           = N.setFlag.toTermName
+      val wait4Notification: TermName = N.wait4Notification.toTermName
+      val state: TermName             = N.state.toTermName
+      val cas: TermName               = N.cas.toTermName
+      val getOffset: TermName         = N.getOffset.toTermName
     }
-    val flag        = "flag".toTermName
-    val result      = "result".toTermName
-    val value       = "value".toTermName
-    val initialized = "initialized".toTermName
-    val retry       = "retry".toTermName
+    val flag: TermName        = "flag".toTermName
+    val result: TermName      = "result".toTermName
+    val value: TermName       = "value".toTermName
+    val initialized: TermName = "initialized".toTermName
+    val retry: TermName       = "retry".toTermName
   }
 }
 
diff --git a/compiler/src/dotty/tools/dotc/transform/LiftTry.scala b/compiler/src/dotty/tools/dotc/transform/LiftTry.scala
index c801779232d6..751db8fc593c 100644
--- a/compiler/src/dotty/tools/dotc/transform/LiftTry.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LiftTry.scala
@@ -36,31 +36,31 @@ class LiftTry extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   private var NeedLift: Store.Location[Boolean] = _
   private def needLift(implicit ctx: Context): Boolean = ctx.store(NeedLift)
 
-  override def initContext(ctx: FreshContext) =
+  override def initContext(ctx: FreshContext): Unit =
     NeedLift = ctx.addLocation(false)
 
   private def liftingCtx(p: Boolean)(implicit ctx: Context) =
     if (needLift == p) ctx else ctx.fresh.updateStore(NeedLift, p)
 
-  override def prepareForApply(tree: Apply)(implicit ctx: Context) =
+  override def prepareForApply(tree: Apply)(implicit ctx: Context): Context =
     if (tree.fun.symbol.is(Label)) ctx
     else liftingCtx(true)
 
-  override def prepareForValDef(tree: ValDef)(implicit ctx: Context) =
+  override def prepareForValDef(tree: ValDef)(implicit ctx: Context): Context =
     if (!tree.symbol.exists  ||
         tree.symbol.isSelfSym ||
         tree.symbol.owner == ctx.owner.enclosingMethod) ctx
     else liftingCtx(true)
 
-  override def prepareForAssign(tree: Assign)(implicit ctx: Context) =
+  override def prepareForAssign(tree: Assign)(implicit ctx: Context): Context =
     if (tree.lhs.symbol.maybeOwner == ctx.owner.enclosingMethod) ctx
     else liftingCtx(true)
 
-  override def prepareForReturn(tree: Return)(implicit ctx: Context) =
+  override def prepareForReturn(tree: Return)(implicit ctx: Context): Context =
     if (!isNonLocalReturn(tree)) ctx
     else liftingCtx(true)
 
-  override def prepareForTemplate(tree: Template)(implicit ctx: Context) =
+  override def prepareForTemplate(tree: Template)(implicit ctx: Context): Context =
     liftingCtx(false)
 
   override def transformTry(tree: Try)(implicit ctx: Context): Tree =
diff --git a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala
index 042c7cff4cbf..d90aa421a52a 100644
--- a/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala
+++ b/compiler/src/dotty/tools/dotc/transform/LinkScala2Impls.scala
@@ -7,17 +7,12 @@ import Contexts.Context
 import Flags._
 import SymUtils._
 import Symbols._
-import SymDenotations._
 import Types._
 import Decorators._
 import DenotTransformers._
 import StdNames._
-import NameOps._
-import Phases._
-import ast.untpd
 import ast.Trees._
 import NameKinds.ImplMethName
-import collection.mutable
 
 /** Rewrite calls
  *
@@ -38,9 +33,9 @@ class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisPhas
   import ast.tpd._
 
   override def phaseName: String = "linkScala2Impls"
-  override def changesMembers = true
+  override def changesMembers: Boolean = true
 
-  override def runsAfterGroupsOf = Set(Mixin.name)
+  override def runsAfterGroupsOf: Set[String] = Set(Mixin.name)
     // Adds as a side effect static members to traits which can confuse Mixin,
     // that's why it is runsAfterGroupOf
 
@@ -63,7 +58,7 @@ class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisPhas
       newImpl(sym.asTerm).enteredAfter(thisPhase)
   }
 
-  override def prepareForTemplate(impl: Template)(implicit ctx: Context) = {
+  override def prepareForTemplate(impl: Template)(implicit ctx: Context): Context = {
     val cls = impl.symbol.owner.asClass
     for (mixin <- cls.mixins)
       if (mixin.is(Scala_2_12_Trait, butNot = Scala_2_12_Augmented)) {
@@ -73,7 +68,7 @@ class LinkScala2Impls extends MiniPhase with IdentityDenotTransformer { thisPhas
     ctx
   }
 
-  override def transformApply(app: Apply)(implicit ctx: Context) = {
+  override def transformApply(app: Apply)(implicit ctx: Context): Tree = {
     def currentClass = ctx.owner.enclosingClass.asClass
     app match {
       case Apply(sel @ Select(Super(_, _), _), args)
diff --git a/compiler/src/dotty/tools/dotc/transform/MacroTransform.scala b/compiler/src/dotty/tools/dotc/transform/MacroTransform.scala
index 5c3dea9cb79e..e8bb69a12509 100644
--- a/compiler/src/dotty/tools/dotc/transform/MacroTransform.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MacroTransform.scala
@@ -2,7 +2,6 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import typer._
 import Phases._
 import ast.Trees._
 import Contexts._
@@ -32,7 +31,7 @@ abstract class MacroTransform extends Phase {
 
   class Transformer extends TreeMap(cpy = cpyBetweenPhases) {
 
-    protected def localCtx(tree: Tree)(implicit ctx: Context) = {
+    protected def localCtx(tree: Tree)(implicit ctx: Context): FreshContext = {
       val sym = tree.symbol
       val owner = if (sym is PackageVal) sym.moduleClass else sym
       ctx.fresh.setTree(tree).setOwner(owner)
@@ -68,7 +67,7 @@ abstract class MacroTransform extends Phase {
           tree
       }
 
-    def transformSelf(vd: ValDef)(implicit ctx: Context) =
+    def transformSelf(vd: ValDef)(implicit ctx: Context): ValDef =
       cpy.ValDef(vd)(tpt = transform(vd.tpt))
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/MacroTransformWithImplicits.scala b/compiler/src/dotty/tools/dotc/transform/MacroTransformWithImplicits.scala
index e6c8e255a265..d00c9027435b 100644
--- a/compiler/src/dotty/tools/dotc/transform/MacroTransformWithImplicits.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MacroTransformWithImplicits.scala
@@ -2,12 +2,9 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import typer._
 import ast.Trees._
 import Contexts._
 import Symbols._
-import Decorators._
-import collection.mutable
 import annotation.tailrec
 
 /** A Macrotransform that maintains the necessary infrastructore to support
@@ -16,7 +13,7 @@ import annotation.tailrec
 abstract class MacroTransformWithImplicits extends MacroTransform {
   import ast.tpd._
 
-  override def allowsImplicitSearch = true
+  override def allowsImplicitSearch: Boolean = true
 
   class ImplicitsTransformer extends Transformer {
 
diff --git a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
index a834ea622b6e..2af1f915265a 100644
--- a/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MegaPhase.scala
@@ -4,13 +4,8 @@ package transform
 
 import core._
 import ast.Trees._
-import Contexts._, Phases._, Periods._, Symbols._, Decorators._
+import Contexts._, Phases._, Symbols._, Decorators._
 import Flags.PackageVal
-import scala.annotation.tailrec
-import config.Printers.transforms
-import scala.util.control.NonFatal
-import reporting.trace
-import annotation.switch
 
 /** A MegaPhase combines a number of mini-phases which are all executed in
  *  a single tree traversal.
@@ -44,46 +39,46 @@ object MegaPhase {
      */
     def runsAfterGroupsOf: Set[String] = Set.empty
 
-    final override def relaxedTyping = superPhase.relaxedTyping
+    final override def relaxedTyping: Boolean = superPhase.relaxedTyping
 
     /** If set, use relaxed typing for all phases in group */
-    def relaxedTypingInGroup = false
+    def relaxedTypingInGroup: Boolean = false
 
     val cpy: TypedTreeCopier = cpyBetweenPhases
 
     def prepareForIdent(tree: Ident)(implicit ctx: Context): Context = ctx
     def prepareForSelect(tree: Select)(implicit ctx: Context): Context = ctx
-    def prepareForThis(tree: This)(implicit ctx: Context) = ctx
-    def prepareForSuper(tree: Super)(implicit ctx: Context) = ctx
-    def prepareForApply(tree: Apply)(implicit ctx: Context) = ctx
-    def prepareForTypeApply(tree: TypeApply)(implicit ctx: Context) = ctx
-    def prepareForLiteral(tree: Literal)(implicit ctx: Context) = ctx
-    def prepareForNew(tree: New)(implicit ctx: Context) = ctx
-    def prepareForTyped(tree: Typed)(implicit ctx: Context) = ctx
-    def prepareForAssign(tree: Assign)(implicit ctx: Context) = ctx
-    def prepareForBlock(tree: Block)(implicit ctx: Context) = ctx
-    def prepareForIf(tree: If)(implicit ctx: Context) = ctx
-    def prepareForClosure(tree: Closure)(implicit ctx: Context) = ctx
-    def prepareForMatch(tree: Match)(implicit ctx: Context) = ctx
-    def prepareForCaseDef(tree: CaseDef)(implicit ctx: Context) = ctx
-    def prepareForLabeled(tree: Labeled)(implicit ctx: Context) = ctx
-    def prepareForReturn(tree: Return)(implicit ctx: Context) = ctx
-    def prepareForWhileDo(tree: WhileDo)(implicit ctx: Context) = ctx
-    def prepareForTry(tree: Try)(implicit ctx: Context) = ctx
-    def prepareForSeqLiteral(tree: SeqLiteral)(implicit ctx: Context) = ctx
-    def prepareForInlined(tree: Inlined)(implicit ctx: Context) = ctx
-    def prepareForTypeTree(tree: TypeTree)(implicit ctx: Context) = ctx
-    def prepareForBind(tree: Bind)(implicit ctx: Context) = ctx
-    def prepareForAlternative(tree: Alternative)(implicit ctx: Context) = ctx
-    def prepareForUnApply(tree: UnApply)(implicit ctx: Context) = ctx
-    def prepareForValDef(tree: ValDef)(implicit ctx: Context) = ctx
-    def prepareForDefDef(tree: DefDef)(implicit ctx: Context) = ctx
-    def prepareForTypeDef(tree: TypeDef)(implicit ctx: Context) = ctx
-    def prepareForTemplate(tree: Template)(implicit ctx: Context) = ctx
-    def prepareForPackageDef(tree: PackageDef)(implicit ctx: Context) = ctx
-    def prepareForStats(trees: List[Tree])(implicit ctx: Context) = ctx
-    def prepareForUnit(tree: Tree)(implicit ctx: Context) = ctx
-    def prepareForOther(tree: Tree)(implicit ctx: Context) = ctx
+    def prepareForThis(tree: This)(implicit ctx: Context): Context = ctx
+    def prepareForSuper(tree: Super)(implicit ctx: Context): Context = ctx
+    def prepareForApply(tree: Apply)(implicit ctx: Context): Context = ctx
+    def prepareForTypeApply(tree: TypeApply)(implicit ctx: Context): Context = ctx
+    def prepareForLiteral(tree: Literal)(implicit ctx: Context): Context = ctx
+    def prepareForNew(tree: New)(implicit ctx: Context): Context = ctx
+    def prepareForTyped(tree: Typed)(implicit ctx: Context): Context = ctx
+    def prepareForAssign(tree: Assign)(implicit ctx: Context): Context = ctx
+    def prepareForBlock(tree: Block)(implicit ctx: Context): Context = ctx
+    def prepareForIf(tree: If)(implicit ctx: Context): Context = ctx
+    def prepareForClosure(tree: Closure)(implicit ctx: Context): Context = ctx
+    def prepareForMatch(tree: Match)(implicit ctx: Context): Context = ctx
+    def prepareForCaseDef(tree: CaseDef)(implicit ctx: Context): Context = ctx
+    def prepareForLabeled(tree: Labeled)(implicit ctx: Context): Context = ctx
+    def prepareForReturn(tree: Return)(implicit ctx: Context): Context = ctx
+    def prepareForWhileDo(tree: WhileDo)(implicit ctx: Context): Context = ctx
+    def prepareForTry(tree: Try)(implicit ctx: Context): Context = ctx
+    def prepareForSeqLiteral(tree: SeqLiteral)(implicit ctx: Context): Context = ctx
+    def prepareForInlined(tree: Inlined)(implicit ctx: Context): Context = ctx
+    def prepareForTypeTree(tree: TypeTree)(implicit ctx: Context): Context = ctx
+    def prepareForBind(tree: Bind)(implicit ctx: Context): Context = ctx
+    def prepareForAlternative(tree: Alternative)(implicit ctx: Context): Context = ctx
+    def prepareForUnApply(tree: UnApply)(implicit ctx: Context): Context = ctx
+    def prepareForValDef(tree: ValDef)(implicit ctx: Context): Context = ctx
+    def prepareForDefDef(tree: DefDef)(implicit ctx: Context): Context = ctx
+    def prepareForTypeDef(tree: TypeDef)(implicit ctx: Context): Context = ctx
+    def prepareForTemplate(tree: Template)(implicit ctx: Context): Context = ctx
+    def prepareForPackageDef(tree: PackageDef)(implicit ctx: Context): Context = ctx
+    def prepareForStats(trees: List[Tree])(implicit ctx: Context): Context = ctx
+    def prepareForUnit(tree: Tree)(implicit ctx: Context): Context = ctx
+    def prepareForOther(tree: Tree)(implicit ctx: Context): Context = ctx
 
     def transformIdent(tree: Ident)(implicit ctx: Context): Tree = tree
     def transformSelect(tree: Select)(implicit ctx: Context): Tree = tree
@@ -131,7 +126,7 @@ object MegaPhase {
     def transformFollowing(tree: Tree)(implicit ctx: Context): Tree =
       superPhase.transformNode(tree, idxInGroup + 1)
 
-    protected def singletonGroup = new MegaPhase(Array(this))
+    protected def singletonGroup: MegaPhase = new MegaPhase(Array(this))
 
     override def run(implicit ctx: Context): Unit =
       singletonGroup.run
@@ -142,14 +137,14 @@ import MegaPhase._
 class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
   import ast.tpd._
 
-  override val phaseName =
+  override val phaseName: String =
     if (miniPhases.length == 1) miniPhases(0).phaseName
     else miniPhases.map(_.phaseName).mkString("MegaPhase{", ", ", "}")
 
   private var relaxedTypingCache: Boolean = _
   private var relaxedTypingKnown = false
 
-  override final def relaxedTyping = {
+  override final def relaxedTyping: Boolean = {
     if (!relaxedTypingKnown) {
       relaxedTypingCache = miniPhases.exists(_.relaxedTypingInGroup)
       relaxedTypingKnown = true
@@ -411,7 +406,7 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
     goStats(trees1, start)(nestedCtx)
   }
 
-  def transformUnit(tree: Tree)(implicit ctx: Context) = {
+  def transformUnit(tree: Tree)(implicit ctx: Context): Tree = {
     val nestedCtx = prepUnit(tree, 0)(ctx)
     val tree1 = transformTree(tree, 0)(nestedCtx)
     goUnit(tree1, 0)(nestedCtx)
diff --git a/compiler/src/dotty/tools/dotc/transform/Memoize.scala b/compiler/src/dotty/tools/dotc/transform/Memoize.scala
index aee354a077c7..aa9414f4ffcf 100644
--- a/compiler/src/dotty/tools/dotc/transform/Memoize.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Memoize.scala
@@ -3,11 +3,9 @@ package transform
 
 import core._
 import DenotTransformers._
-import Phases.Phase
 import Contexts.Context
 import SymDenotations.SymDenotation
 import Denotations._
-import Types._
 import Symbols._
 import SymUtils._
 import Constants._
@@ -18,7 +16,7 @@ import Flags._
 import Decorators._
 
 object Memoize {
-  val name = "memoize"
+  val name: String = "memoize"
 }
 
 /** Provides the implementations of all getters and setters, introducing
@@ -39,7 +37,7 @@ object Memoize {
 class Memoize extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   import ast.tpd._
 
-  override def phaseName = Memoize.name
+  override def phaseName: String = Memoize.name
 
   /* Makes sure that, after getters and constructors gen, there doesn't
    * exist non-deferred definitions that are not implemented. */
@@ -68,7 +66,7 @@ class Memoize extends MiniPhase with IdentityDenotTransformer { thisPhase =>
    *  class that contains the concrete getter rather than the trait
    *  that defines it.
    */
-  override def runsAfter = Set(Mixin.name)
+  override def runsAfter: Set[String] = Set(Mixin.name)
 
   override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree = {
     val sym = tree.symbol
diff --git a/compiler/src/dotty/tools/dotc/transform/Mixin.scala b/compiler/src/dotty/tools/dotc/transform/Mixin.scala
index 672b6d0d625b..424b1fbab5b7 100644
--- a/compiler/src/dotty/tools/dotc/transform/Mixin.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Mixin.scala
@@ -12,15 +12,12 @@ import Types._
 import Decorators._
 import DenotTransformers._
 import StdNames._
-import NameOps._
 import NameKinds._
-import Phases._
-import ast.untpd
 import ast.Trees._
 import collection.mutable
 
 object Mixin {
-  val name = "mixin"
+  val name: String = "mixin"
 }
 
 /** This phase performs the following transformations:
@@ -100,12 +97,12 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
 
   override def phaseName: String = Mixin.name
 
-  override def relaxedTypingInGroup = true
+  override def relaxedTypingInGroup: Boolean = true
     // Because it changes number of parameters in trait initializers
 
-  override def runsAfter = Set(Erasure.name)
+  override def runsAfter: Set[String] = Set(Erasure.name)
 
-  override def changesMembers = true  // the phase adds implementions of mixin accessors
+  override def changesMembers: Boolean = true  // the phase adds implementions of mixin accessors
 
   override def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation =
     if (sym.is(Accessor, butNot = Deferred) && sym.owner.is(Trait)) {
@@ -136,7 +133,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
     }
   }.asTerm
 
-  override def transformTemplate(impl: Template)(implicit ctx: Context) = {
+  override def transformTemplate(impl: Template)(implicit ctx: Context): Template = {
     val cls = impl.symbol.owner.asClass
     val ops = new MixinOps(cls, thisPhase)
     import ops._
diff --git a/compiler/src/dotty/tools/dotc/transform/MixinOps.scala b/compiler/src/dotty/tools/dotc/transform/MixinOps.scala
index 16dbd0ad3ba6..785f1d0bbf36 100644
--- a/compiler/src/dotty/tools/dotc/transform/MixinOps.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MixinOps.scala
@@ -2,7 +2,7 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import Symbols._, Types._, Contexts._, SymDenotations._, DenotTransformers._, Flags._
+import Symbols._, Types._, Contexts._, DenotTransformers._, Flags._
 import util.Positions._
 import SymUtils._
 import StdNames._, NameOps._
@@ -42,7 +42,7 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
   /** Is `sym` a member of implementing class `cls`?
    *  The test is performed at phase `thisPhase`.
    */
-  def isCurrent(sym: Symbol) =
+  def isCurrent(sym: Symbol): Boolean =
     ctx.atPhase(thisPhase) { implicit ctx =>
       cls.info.nonPrivateMember(sym.name).hasAltWith(_.symbol == sym)
       // this is a hot spot, where we spend several seconds while compiling stdlib
@@ -94,11 +94,12 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(implicit ctx: Cont
     else competingMethodsIterator(meth).find(needsPrimitiveForwarder)
   }
 
-  final val PrivateOrAccessor = Private | Accessor
-  final val PrivateOrAccessorOrDeferred = Private | Accessor | Deferred
+  final val PrivateOrAccessor: FlagSet = Private | Accessor
+  final val PrivateOrAccessorOrDeferred: FlagSet = Private | Accessor | Deferred
 
-  def forwarder(target: Symbol) = (targs: List[Type]) => (vrefss: List[List[Tree]]) =>
-    superRef(target).appliedToTypes(targs).appliedToArgss(vrefss)
+  def forwarder(target: Symbol): List[Type] => List[List[Tree]] => Tree =
+    targs => vrefss =>
+      superRef(target).appliedToTypes(targs).appliedToArgss(vrefss)
 
   private def competingMethodsIterator(meth: Symbol): Iterator[Symbol] = {
     cls.baseClasses.iterator
diff --git a/compiler/src/dotty/tools/dotc/transform/MoveStatics.scala b/compiler/src/dotty/tools/dotc/transform/MoveStatics.scala
index c71dba2b9640..8b06551fb1d4 100644
--- a/compiler/src/dotty/tools/dotc/transform/MoveStatics.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MoveStatics.scala
@@ -3,27 +3,25 @@ package dotty.tools.dotc.transform
 import dotty.tools.dotc.ast.{Trees, tpd}
 import dotty.tools.dotc.core.Annotations.Annotation
 import dotty.tools.dotc.core.Contexts.Context
-import dotty.tools.dotc.core.DenotTransformers.{InfoTransformer, SymTransformer}
+import dotty.tools.dotc.core.DenotTransformers.SymTransformer
 import dotty.tools.dotc.core.SymDenotations.SymDenotation
-import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.NameOps._
-import dotty.tools.dotc.core.{Flags, Names}
+import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Names.Name
 import dotty.tools.dotc.core.StdNames.nme
-import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.core.Types.MethodType
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
 
 object MoveStatics {
-  val name = "moveStatic"
+  val name: String = "moveStatic"
 }
 
 /** Move static methods from companion to the class itself */
 class MoveStatics extends MiniPhase with SymTransformer {
 
   import tpd._
-  override def phaseName = MoveStatics.name
+  override def phaseName: String = MoveStatics.name
 
   def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation = {
     if (sym.hasAnnotation(defn.ScalaStaticAnnot) && sym.owner.is(Flags.Module) && sym.owner.companionClass.exists) {
diff --git a/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala b/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala
index 80b6944625f8..23c0fb222b6c 100644
--- a/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala
+++ b/compiler/src/dotty/tools/dotc/transform/NonLocalReturns.scala
@@ -2,27 +2,25 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import Contexts._, Symbols._, Types._, Flags._, Decorators._, StdNames._, Constants._, Phases._
+import Contexts._, Symbols._, Types._, Flags._, StdNames._
 import MegaPhase._
-import ast.Trees._
 import NameKinds.NonLocalReturnKeyName
-import collection.mutable
 
 object NonLocalReturns {
   import ast.tpd._
-  def isNonLocalReturn(ret: Return)(implicit ctx: Context) =
+  def isNonLocalReturn(ret: Return)(implicit ctx: Context): Boolean =
     !ret.from.symbol.is(Label) && (ret.from.symbol != ctx.owner.enclosingMethod || ctx.owner.is(Lazy))
 }
 
 /** Implement non-local returns using NonLocalReturnControl exceptions.
  */
 class NonLocalReturns extends MiniPhase {
-  override def phaseName = "nonLocalReturns"
+  override def phaseName: String = "nonLocalReturns"
 
   import NonLocalReturns._
   import ast.tpd._
 
-  override def runsAfter = Set(ElimByName.name)
+  override def runsAfter: Set[String] = Set(ElimByName.name)
 
   private def ensureConforms(tree: Tree, pt: Type)(implicit ctx: Context) =
     if (tree.tpe <:< pt) tree
diff --git a/compiler/src/dotty/tools/dotc/transform/OverridingPairs.scala b/compiler/src/dotty/tools/dotc/transform/OverridingPairs.scala
index 2f166891f353..9f73b4e53ae0 100644
--- a/compiler/src/dotty/tools/dotc/transform/OverridingPairs.scala
+++ b/compiler/src/dotty/tools/dotc/transform/OverridingPairs.scala
@@ -2,8 +2,7 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import Flags._, Symbols._, Contexts._, Types._, Scopes._, Decorators._
-import util.HashSet
+import Flags._, Symbols._, Contexts._, Scopes._, Decorators._
 import collection.mutable
 import collection.immutable.BitSet
 import scala.annotation.tailrec
diff --git a/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala b/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala
index b876a3a9b47e..138fe95114af 100644
--- a/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ParamForwarding.scala
@@ -4,7 +4,7 @@ package transform
 import core._
 import ast.Trees._
 import Contexts._, Types._, Symbols._, Flags._, TypeUtils._, DenotTransformers._, StdNames._
-import Decorators._, NameOps._
+import Decorators._
 import config.Printers.typr
 
 /** For all parameter accessors
diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
index a04c7329710a..1ab82d6579ee 100644
--- a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -5,17 +5,17 @@ import scala.annotation.tailrec
 import core._
 import MegaPhase._
 import collection.mutable
-import SymDenotations._, Symbols._, Contexts._, Types._, Names._, StdNames._, NameOps._
+import Symbols._, Contexts._, Types._, StdNames._, NameOps._
 import ast.Trees._
 import util.Positions._
 import typer.Applications.{isProductMatch, isGetMatch, productSelectors}
 import SymUtils._
 import Flags._, Constants._
 import Decorators._
-import patmat.Space
-import NameKinds.{UniqueNameKind, PatMatStdBinderName, PatMatAltsName, PatMatResultName}
+import NameKinds.{PatMatStdBinderName, PatMatAltsName, PatMatResultName}
 import config.Printers.patmatch
 import reporting.diagnostic.messages._
+import dotty.tools.dotc.ast._
 
 /** The pattern matching transform.
  *  After this phase, the only Match nodes remaining in the code are simple switches
@@ -25,8 +25,8 @@ class PatternMatcher extends MiniPhase {
   import ast.tpd._
   import PatternMatcher._
 
-  override def phaseName = PatternMatcher.name
-  override def runsAfter = Set(ElimRepeated.name)
+  override def phaseName: String = PatternMatcher.name
+  override def runsAfter: Set[String] = Set(ElimRepeated.name)
 
   override def transformMatch(tree: Match)(implicit ctx: Context): Tree = {
     val translated = new Translator(tree.tpe, this).translateMatch(tree)
@@ -43,7 +43,7 @@ class PatternMatcher extends MiniPhase {
 object PatternMatcher {
   import ast.tpd._
 
-  val name = "patternMatcher"
+  val name: String = "patternMatcher"
 
   final val selfCheck = false // debug option, if on we check that no case gets generated twice
 
@@ -127,15 +127,15 @@ object PatternMatcher {
     private[this] var nxId = 0
 
     /** The different kinds of plans */
-    sealed abstract class Plan { val id = nxId; nxId += 1 }
+    sealed abstract class Plan { val id: Int = nxId; nxId += 1 }
 
     case class TestPlan(test: Test, var scrutinee: Tree, pos: Position,
                         var onSuccess: Plan) extends Plan {
-      override def equals(that: Any) = that match {
+      override def equals(that: Any): Boolean = that match {
         case that: TestPlan => this.scrutinee === that.scrutinee && this.test == that.test
         case _ => false
       }
-      override def hashCode = scrutinee.hash * 41 + test.hashCode
+      override def hashCode: Int = scrutinee.hash * 41 + test.hashCode
     }
 
     case class LetPlan(sym: TermSymbol, var body: Plan) extends Plan
@@ -152,18 +152,18 @@ object PatternMatcher {
     /** The different kinds of tests */
     sealed abstract class Test
     case class TypeTest(tpt: Tree) extends Test {                 // scrutinee.isInstanceOf[tpt]
-      override def equals(that: Any) = that match {
+      override def equals(that: Any): Boolean = that match {
         case that: TypeTest => this.tpt.tpe =:= that.tpt.tpe
         case _ => false
       }
-      override def hashCode = tpt.tpe.hash
+      override def hashCode: Int = tpt.tpe.hash
     }
     case class EqualTest(tree: Tree) extends Test {               // scrutinee == tree
-      override def equals(that: Any) = that match {
+      override def equals(that: Any): Boolean = that match {
         case that: EqualTest => this.tree === that.tree
         case _ => false
       }
-      override def hashCode = tree.hash
+      override def hashCode: Int = tree.hash
     }
     case class LengthTest(len: Int, exact: Boolean) extends Test  // scrutinee (== | >=) len
     case object NonEmptyTest extends Test                         // !scrutinee.isEmpty
@@ -387,7 +387,7 @@ object PatternMatcher {
 
     /** A superclass for plan transforms */
     class PlanTransform extends (Plan => Plan) {
-      protected val treeMap = new TreeMap {
+      protected val treeMap: TreeMap = new TreeMap {
         override def transform(tree: Tree)(implicit ctx: Context) = tree
       }
       def apply(tree: Tree): Tree = treeMap.transform(tree)
diff --git a/compiler/src/dotty/tools/dotc/transform/Pickler.scala b/compiler/src/dotty/tools/dotc/transform/Pickler.scala
index 72b6f9e799f7..d7b92e3430ef 100644
--- a/compiler/src/dotty/tools/dotc/transform/Pickler.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Pickler.scala
@@ -15,7 +15,7 @@ import reporting.ThrowingReporter
 import collection.mutable
 
 object Pickler {
-  val name = "pickler"
+  val name: String = "pickler"
 }
 
 /** This phase pickles trees */
diff --git a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
index b9b06f50691b..5cd8795b4d04 100644
--- a/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PostTyper.scala
@@ -5,14 +5,14 @@ import dotty.tools.dotc.ast.{Trees, tpd, untpd}
 import scala.collection.mutable
 import core._
 import typer.Checking
-import Types._, Contexts._, Names._, Flags._, DenotTransformers._
+import Types._, Contexts._, Names._, Flags._, DenotTransformers._, Phases._
 import SymDenotations._, StdNames._, Annotations._, Trees._, Scopes._
 import Decorators._
 import Symbols._, SymUtils._
 import reporting.diagnostic.messages._
 
 object PostTyper {
-  val name = "posttyper"
+  val name: String = "posttyper"
 }
 
 /** A macro transform that runs immediately after typer and that performs the following functions:
@@ -56,16 +56,16 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
   /** the following two members override abstract members in Transform */
   override def phaseName: String = PostTyper.name
 
-  override def changesMembers = true // the phase adds super accessors and synthetic methods
+  override def changesMembers: Boolean = true // the phase adds super accessors and synthetic methods
 
-  override def transformPhase(implicit ctx: Context) = thisPhase.next
+  override def transformPhase(implicit ctx: Context): Phase = thisPhase.next
 
   protected def newTransformer(implicit ctx: Context): Transformer =
     new PostTyperTransformer
 
-  val superAcc = new SuperAccessors(thisPhase)
-  val paramFwd = new ParamForwarding(thisPhase)
-  val synthMth = new SyntheticMethods(thisPhase)
+  val superAcc: SuperAccessors = new SuperAccessors(thisPhase)
+  val paramFwd: ParamForwarding = new ParamForwarding(thisPhase)
+  val synthMth: SyntheticMethods = new SyntheticMethods(thisPhase)
 
   private def newPart(tree: Tree): Option[New] = methPart(tree) match {
     case Select(nu: New, _) => Some(nu)
@@ -88,7 +88,7 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer { thisPhase
       try op finally noCheckNews = saved
     }
 
-    def isCheckable(t: New) = !inJavaAnnot && !noCheckNews.contains(t)
+    def isCheckable(t: New): Boolean = !inJavaAnnot && !noCheckNews.contains(t)
 
     private def transformAnnot(annot: Tree)(implicit ctx: Context): Tree = {
       val saved = inJavaAnnot
diff --git a/compiler/src/dotty/tools/dotc/transform/PrimitiveForwarders.scala b/compiler/src/dotty/tools/dotc/transform/PrimitiveForwarders.scala
index 853c74c815c9..051d4307367a 100644
--- a/compiler/src/dotty/tools/dotc/transform/PrimitiveForwarders.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PrimitiveForwarders.scala
@@ -4,20 +4,8 @@ package transform
 import core._
 import MegaPhase._
 import Contexts.Context
-import Flags._
-import SymUtils._
 import Symbols._
-import SymDenotations._
-import Types._
-import Decorators._
 import DenotTransformers._
-import StdNames._
-import NameOps._
-import ast.Trees._
-import util.Positions._
-import Names._
-import collection.mutable
-import ResolveSuper._
 
 /** This phase adds forwarder where mixedin generic and primitive typed methods have a missmatch.
   *  In particular for every method that is declared both as generic with a primitive type and with a primitive type
@@ -35,11 +23,11 @@ class PrimitiveForwarders extends MiniPhase with IdentityDenotTransformer { this
 
   override def phaseName: String = "primitiveForwarders"
 
-  override def runsAfter = Set(ResolveSuper.name)
+  override def runsAfter: Set[String] = Set(ResolveSuper.name)
 
-  override def changesMembers = true   // the phase adds primitive forwarders
+  override def changesMembers: Boolean = true   // the phase adds primitive forwarders
 
-  override def transformTemplate(impl: Template)(implicit ctx: Context) = {
+  override def transformTemplate(impl: Template)(implicit ctx: Context): Template = {
     val cls = impl.symbol.owner.asClass
     val ops = new MixinOps(cls, thisPhase)
     import ops._
diff --git a/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala b/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
index 4528d735d12d..dadd92fb11a8 100644
--- a/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ProtectedAccessors.scala
@@ -7,7 +7,6 @@ import core.Symbols._
 import core.Flags._
 import core.Decorators._
 import MegaPhase.MiniPhase
-import ast.Trees._
 import config.Printers.transforms
 
 /** Add accessors for all protected accesses. An accessor is needed if
@@ -16,7 +15,7 @@ import config.Printers.transforms
  *  class. In this point a public access method is placed in that enclosing class.
  */
 object ProtectedAccessors {
-  val name = "protectedAccessors"
+  val name: String = "protectedAccessors"
 
   /** Is the current context's owner inside the access boundary established by `sym`? */
   def insideBoundaryOf(sym: Symbol)(implicit ctx: Context): Boolean = {
@@ -49,12 +48,11 @@ object ProtectedAccessors {
 
 class ProtectedAccessors extends MiniPhase {
   import ast.tpd._
-  import ProtectedAccessors._
 
-  override def phaseName = ProtectedAccessors.name
+  override def phaseName: String = ProtectedAccessors.name
 
   object Accessors extends AccessProxies {
-    val insert = new Insert {
+    val insert: Insert = new Insert {
       def accessorNameKind = ProtectedAccessorName
       def needsAccessor(sym: Symbol)(implicit ctx: Context) = ProtectedAccessors.needsAccessor(sym)
 
diff --git a/compiler/src/dotty/tools/dotc/transform/PruneErasedDefs.scala b/compiler/src/dotty/tools/dotc/transform/PruneErasedDefs.scala
index 2da2fcd08122..2aeb0a186434 100644
--- a/compiler/src/dotty/tools/dotc/transform/PruneErasedDefs.scala
+++ b/compiler/src/dotty/tools/dotc/transform/PruneErasedDefs.scala
@@ -7,7 +7,6 @@ import DenotTransformers.SymTransformer
 import Flags._
 import SymDenotations._
 import Symbols._
-import Types._
 import typer.RefChecks
 import MegaPhase.MiniPhase
 import ast.tpd
@@ -22,32 +21,32 @@ import ast.tpd
 class PruneErasedDefs extends MiniPhase with SymTransformer { thisTransform =>
   import tpd._
 
-  override def phaseName = PruneErasedDefs.name
+  override def phaseName: String = PruneErasedDefs.name
 
-  override def changesMembers = true   // makes erased members private
+  override def changesMembers: Boolean = true   // makes erased members private
 
-  override def runsAfterGroupsOf = Set(RefChecks.name, ExplicitOuter.name)
+  override def runsAfterGroupsOf: Set[String] = Set(RefChecks.name, ExplicitOuter.name)
 
   override def transformSym(sym: SymDenotation)(implicit ctx: Context): SymDenotation =
     if (sym.isEffectivelyErased && !sym.is(Private) && sym.owner.isClass)
       sym.copySymDenotation(initFlags = sym.flags | Private)
     else sym
 
-  override def transformApply(tree: Apply)(implicit ctx: Context) =
+  override def transformApply(tree: Apply)(implicit ctx: Context): Tree =
     if (tree.fun.tpe.widen.isErasedMethod)
       cpy.Apply(tree)(tree.fun, tree.args.map(arg => ref(defn.Predef_undefined)))
     else tree
 
-  override def transformValDef(tree: ValDef)(implicit ctx: Context) =
+  override def transformValDef(tree: ValDef)(implicit ctx: Context): Tree =
     if (tree.symbol.isEffectivelyErased && !tree.rhs.isEmpty)
       cpy.ValDef(tree)(rhs = ref(defn.Predef_undefined))
     else tree
 
-  override def transformDefDef(tree: DefDef)(implicit ctx: Context) =
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context): Tree =
     if (tree.symbol.isEffectivelyErased && !tree.rhs.isEmpty)
       cpy.DefDef(tree)(rhs = ref(defn.Predef_undefined))
     else tree
 }
 object PruneErasedDefs {
-  val name = "pruneErasedDefs"
+  val name: String = "pruneErasedDefs"
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala b/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala
index 72a42975dded..60cb93008f31 100644
--- a/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ReifyQuotes.scala
@@ -635,7 +635,7 @@ class ReifyQuotes extends MacroTransformWithImplicits {
 }
 
 object ReifyQuotes {
-  val name = "reifyQuotes"
+  val name: String = "reifyQuotes"
 
   def toValue(tree: tpd.Tree): Option[Any] = tree match {
     case Literal(Constant(c)) => Some(c)
diff --git a/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala b/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala
index ea7180b51917..51f494c4d951 100644
--- a/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala
+++ b/compiler/src/dotty/tools/dotc/transform/RenameLifted.scala
@@ -6,7 +6,6 @@ import dotty.tools.dotc.core.DenotTransformers.SymTransformer
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.NameKinds._
 import dotty.tools.dotc.core.Names._
-import dotty.tools.dotc.core.Phases
 import dotty.tools.dotc.core.SymDenotations.SymDenotation
 import dotty.tools.dotc.core.Symbols._
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
@@ -14,7 +13,7 @@ import dotty.tools.dotc.transform.MegaPhase.MiniPhase
 /** Renames lifted classes to local numbering scheme */
 class RenameLifted extends MiniPhase with SymTransformer {
 
-  override def phaseName = "renameLifted"
+  override def phaseName: String = "renameLifted"
 
   // Not clear why this should run after restoreScopes
   // override def runsAfterGroupsOf = Set(RestoreScopes.name)
diff --git a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala
index 4a9e4409ffa6..be3661259e55 100644
--- a/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ResolveSuper.scala
@@ -7,17 +7,10 @@ import Contexts.Context
 import Flags._
 import SymUtils._
 import Symbols._
-import SymDenotations._
-import Types._
 import Decorators._
 import DenotTransformers._
-import StdNames._
 import NameOps._
 import NameKinds._
-import ast.Trees._
-import util.Positions._
-import Names._
-import collection.mutable
 import ResolveSuper._
 
 /** This phase adds super accessors and method overrides where
@@ -50,13 +43,13 @@ class ResolveSuper extends MiniPhase with IdentityDenotTransformer { thisPhase =
 
   override def phaseName: String = ResolveSuper.name
 
-  override def runsAfter = Set(ElimByName.name, // verified empirically, need to figure out what the reason is.
+  override def runsAfter: Set[String] = Set(ElimByName.name, // verified empirically, need to figure out what the reason is.
                                AugmentScala2Traits.name,
                                PruneErasedDefs.name) // Erased decls make `isCurrent` work incorrectly
 
-  override def changesMembers = true // the phase adds super accessors and method forwarders
+  override def changesMembers: Boolean = true // the phase adds super accessors and method forwarders
 
-  override def transformTemplate(impl: Template)(implicit ctx: Context) = {
+  override def transformTemplate(impl: Template)(implicit ctx: Context): Template = {
     val cls = impl.symbol.owner.asClass
     val ops = new MixinOps(cls, thisPhase)
     import ops._
@@ -80,7 +73,7 @@ class ResolveSuper extends MiniPhase with IdentityDenotTransformer { thisPhase =
     cpy.Template(impl)(body = overrides ::: impl.body)
   }
 
-  override def transformDefDef(ddef: DefDef)(implicit ctx: Context) = {
+  override def transformDefDef(ddef: DefDef)(implicit ctx: Context): Tree = {
     val meth = ddef.symbol.asTerm
     if (meth.isSuperAccessor && !meth.is(Deferred)) {
       assert(ddef.rhs.isEmpty)
@@ -94,7 +87,7 @@ class ResolveSuper extends MiniPhase with IdentityDenotTransformer { thisPhase =
 }
 
 object ResolveSuper {
-  val name = "resolveSuper"
+  val name: String = "resolveSuper"
 
   /** Returns the symbol that is accessed by a super-accessor in a mixin composition.
    *
diff --git a/compiler/src/dotty/tools/dotc/transform/RestoreScopes.scala b/compiler/src/dotty/tools/dotc/transform/RestoreScopes.scala
index b88d46fdda6a..2abd04eb253e 100644
--- a/compiler/src/dotty/tools/dotc/transform/RestoreScopes.scala
+++ b/compiler/src/dotty/tools/dotc/transform/RestoreScopes.scala
@@ -6,11 +6,8 @@ import DenotTransformers.IdentityDenotTransformer
 import Contexts.Context
 import Symbols._
 import Scopes._
-import collection.mutable
 import MegaPhase.MiniPhase
-import SymDenotations._
 import ast.Trees._
-import NameOps._
 import StdNames._
 
 /** The preceding lambda lift and flatten phases move symbols to different scopes
@@ -19,16 +16,16 @@ import StdNames._
  */
 class RestoreScopes extends MiniPhase with IdentityDenotTransformer { thisPhase =>
   import ast.tpd._
-  override def phaseName = "restoreScopes"
+  override def phaseName: String = "restoreScopes"
 
-  override def changesMembers = true // the phase affects scopes, applying tree transformations of previous phases
+  override def changesMembers: Boolean = true // the phase affects scopes, applying tree transformations of previous phases
 
   /* Note: We need to wait until we see a package definition because
    * DropEmptyConstructors changes template members when analyzing the
    * enclosing package definitions. So by the time RestoreScopes gets to
    * see a typedef or template, it still might be changed by DropEmptyConstructors.
    */
-  override def transformPackageDef(pdef: PackageDef)(implicit ctx: Context) = {
+  override def transformPackageDef(pdef: PackageDef)(implicit ctx: Context): PackageDef = {
     pdef.stats.foreach(restoreScope)
     pdef
   }
diff --git a/compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala b/compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala
index 2e17a211a04d..b6daa0f1388c 100644
--- a/compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SeqLiterals.scala
@@ -2,12 +2,8 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import Types._
 import dotty.tools.dotc.transform.MegaPhase._
 import Contexts.Context
-import Symbols._
-import Phases._
-import Decorators._
 
 /** A transformer that eliminates SeqLiteral's, transforming `SeqLiteral(elems)` to an operation
  *  equivalent to
@@ -21,8 +17,8 @@ import Decorators._
 class SeqLiterals extends MiniPhase {
   import ast.tpd._
 
-  override def phaseName = "seqLiterals"
-  override def runsAfter = Set(PatternMatcher.name)
+  override def phaseName: String = "seqLiterals"
+  override def runsAfter: Set[String] = Set(PatternMatcher.name)
 
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match {
     case tpd: SeqLiteral => assert(tpd.isInstanceOf[JavaSeqLiteral])
diff --git a/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala b/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala
index dfd7ae8335e8..f574a34a6685 100644
--- a/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ShortcutImplicits.scala
@@ -7,15 +7,11 @@ import core.Symbols._
 import core.Contexts._
 import core.Types._
 import core.Flags._
-import core.Decorators._
 import core.StdNames.nme
-import core.Names._
-import core.NameOps._
 import core.NameKinds.DirectMethodName
 import ast.Trees._
 import ast.tpd
 import util.Store
-import collection.mutable
 
 /** This phase optimizes code using implicit function types, by applying two rewrite rules.
  *  Let IF be the implicit function type
@@ -63,7 +59,7 @@ class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisPh
 
   override def phaseName: String = ShortcutImplicits.name
 
-  override def changesMembers = true  // the phase adds "direct" methods
+  override def changesMembers: Boolean = true  // the phase adds "direct" methods
 
   /** A map to cache mapping local methods to their direct counterparts.
    *  A fresh map is created for each unit.
@@ -71,11 +67,11 @@ class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisPh
   private var DirectMeth: Store.Location[MutableSymbolMap[Symbol]] = _
   private def directMeth(implicit ctx: Context) = ctx.store(DirectMeth)
 
-  override def initContext(ctx: FreshContext) =
+  override def initContext(ctx: FreshContext): Unit =
     DirectMeth = ctx.addLocation[MutableSymbolMap[Symbol]]()
 
 
-  override def prepareForUnit(tree: Tree)(implicit ctx: Context) =
+  override def prepareForUnit(tree: Tree)(implicit ctx: Context): Context =
     ctx.fresh.updateStore(DirectMeth, newMutableSymbolMap[Symbol])
 
 
@@ -87,7 +83,7 @@ class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisPh
     else directMeth.getOrElseUpdate(sym, newShortcutMethod(sym))
 
   /** Transform `qual.apply` occurrences according to rewrite rule (2) above */
-  override def transformSelect(tree: Select)(implicit ctx: Context) =
+  override def transformSelect(tree: Select)(implicit ctx: Context): Tree =
     if (tree.name == nme.apply &&
         defn.isImplicitFunctionType(tree.qualifier.tpe.widen) &&
         needsImplicitShortcut(tree.qualifier.symbol)) {
@@ -147,7 +143,7 @@ class ShortcutImplicits extends MiniPhase with IdentityDenotTransformer { thisPh
 }
 
 object ShortcutImplicits {
-  val name = "shortcutImplicits"
+  val name: String = "shortcutImplicits"
 
   /** If this option is true, we don't specialize symbols that are known to be only
    *  targets of monomorphic calls.
@@ -163,7 +159,7 @@ object ShortcutImplicits {
     *  to be only targets of monomorphic calls because they are effectively
     *  final and don't override anything.
     */
-  def needsImplicitShortcut(sym: Symbol)(implicit ctx: Context) =
+  def needsImplicitShortcut(sym: Symbol)(implicit ctx: Context): Boolean =
     sym.is(Method, butNot = Accessor) &&
     defn.isImplicitFunctionType(sym.info.finalResultType) &&
     defn.functionArity(sym.info.finalResultType) > 0 &&
@@ -191,12 +187,12 @@ object ShortcutImplicits {
     direct
   }
 
-  def shortcutMethod(sym: Symbol, phase: DenotTransformer)(implicit ctx: Context) =
+  def shortcutMethod(sym: Symbol, phase: DenotTransformer)(implicit ctx: Context): Symbol =
     sym.owner.info.decl(DirectMethodName(sym.name.asTermName))
       .suchThat(_.info matches directInfo(sym.info)).symbol
       .orElse(newShortcutMethod(sym).enteredAfter(phase))
 
-  def isImplicitShortcut(sym: Symbol)(implicit ctx: Context) = sym.name.is(DirectMethodName)
+  def isImplicitShortcut(sym: Symbol)(implicit ctx: Context): Boolean = sym.name.is(DirectMethodName)
 }
 
 
diff --git a/compiler/src/dotty/tools/dotc/transform/Splitter.scala b/compiler/src/dotty/tools/dotc/transform/Splitter.scala
index f8093d0f8cf5..2f969748229d 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splitter.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splitter.scala
@@ -4,10 +4,10 @@ package transform
 import MegaPhase._
 import ast.Trees._
 import core._
-import Contexts._, Types._, Decorators._, Denotations._, Symbols._, SymDenotations._, Names._
+import Contexts._, Types._
 
 object Splitter {
-  val name = "splitter"
+  val name: String = "splitter"
 }
 
 /** Distribute applications into Block and If nodes
@@ -18,7 +18,7 @@ class Splitter extends MiniPhase {
   override def phaseName: String = Splitter.name
 
   /** Distribute arguments among splitted branches */
-  def distribute(tree: GenericApply[Type], rebuild: (Tree, List[Tree]) => Context => Tree)(implicit ctx: Context) = {
+  def distribute(tree: GenericApply[Type], rebuild: (Tree, List[Tree]) => Context => Tree)(implicit ctx: Context): Tree = {
     def recur(fn: Tree): Tree = fn match {
       case Block(stats, expr) => Block(stats, recur(expr))
       case If(cond, thenp, elsep) => If(cond, recur(thenp), recur(elsep))
@@ -32,13 +32,13 @@ class Splitter extends MiniPhase {
     case _ => false
   }
 
-  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context) =
+  override def transformTypeApply(tree: TypeApply)(implicit ctx: Context): Tree =
     if (needsDistribution(tree.fun))
       distribute(tree, typeApply)
     else
       tree
 
-  override def transformApply(tree: Apply)(implicit ctx: Context) =
+  override def transformApply(tree: Apply)(implicit ctx: Context): Tree =
     if (needsDistribution(tree.fun))
       distribute(tree, apply)
     else
diff --git a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
index 2cdc5b2c2525..d647127a68c3 100644
--- a/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SuperAccessors.scala
@@ -5,7 +5,7 @@ import dotty.tools.dotc.ast.{Trees, tpd}
 import scala.collection.mutable
 import ValueClasses.isMethodWithExtension
 import core._
-import Types._, Contexts._, Names._, Flags._, Symbols._, NameOps._, Trees._
+import Contexts._, Flags._, Symbols._, NameOps._, Trees._
 import TypeUtils._, SymUtils._
 import DenotTransformers.DenotTransformer
 import Symbols._
@@ -139,7 +139,7 @@ class SuperAccessors(thisPhase: DenotTransformer) {
       (sym eq defn.Any_##)
 
     /** Transform select node, adding super and protected accessors as needed */
-    def transformSelect(tree: Tree, targs: List[Tree])(implicit ctx: Context) = {
+    def transformSelect(tree: Tree, targs: List[Tree])(implicit ctx: Context): Tree = {
       val sel @ Select(qual, name) = tree
       val sym = sel.symbol
 
@@ -172,7 +172,7 @@ class SuperAccessors(thisPhase: DenotTransformer) {
     }
 
     /** Wrap template to template transform `op` with needed initialization and finalization */
-    def wrapTemplate(tree: Template)(op: Template => Template)(implicit ctx: Context) = {
+    def wrapTemplate(tree: Template)(op: Template => Template)(implicit ctx: Context): Template = {
       accDefs(currentClass) = new mutable.ListBuffer[Tree]
       val impl = op(tree)
       val accessors = accDefs.remove(currentClass).get
@@ -188,6 +188,6 @@ class SuperAccessors(thisPhase: DenotTransformer) {
     }
 
     /** Wrap `DefDef` producing operation `op`, potentially setting `invalidClass` info */
-    def wrapDefDef(ddef: DefDef)(op: => DefDef)(implicit ctx: Context) =
+    def wrapDefDef(ddef: DefDef)(op: => DefDef)(implicit ctx: Context): DefDef =
       if (isMethodWithExtension(ddef.symbol)) withInvalidCurrentClass(op) else op
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
index aabd341533e2..540b372c3197 100644
--- a/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SymUtils.scala
@@ -6,9 +6,7 @@ import Types._
 import Contexts._
 import Symbols._
 import SymDenotations._
-import Decorators._
 import Names._
-import StdNames._
 import NameOps._
 import NameKinds._
 import Flags._
@@ -66,7 +64,7 @@ class SymUtils(val self: Symbol) extends AnyVal {
     if (self.isConstructor) self.owner else self
 
   /** The closest properly enclosing method or class of this symbol. */
-  final def enclosure(implicit ctx: Context) = {
+  final def enclosure(implicit ctx: Context): Symbol = {
     self.owner.enclosingMethodOrClass
   }
 
@@ -123,7 +121,7 @@ class SymUtils(val self: Symbol) extends AnyVal {
     self
   }
 
-  def registerCompanionMethod(name: Name, target: Symbol)(implicit ctx: Context) = {
+  def registerCompanionMethod(name: Name, target: Symbol)(implicit ctx: Context): Any = {
     if (!self.unforcedDecls.lookup(name).exists) {
       val companionMethod = ctx.synthesizeCompanionMethod(name, target, self)
       if (companionMethod.exists) {
diff --git a/compiler/src/dotty/tools/dotc/transform/SyntheticMethods.scala b/compiler/src/dotty/tools/dotc/transform/SyntheticMethods.scala
index 86dcbbed2196..0b9dde117732 100644
--- a/compiler/src/dotty/tools/dotc/transform/SyntheticMethods.scala
+++ b/compiler/src/dotty/tools/dotc/transform/SyntheticMethods.scala
@@ -2,19 +2,13 @@ package dotty.tools.dotc
 package transform
 
 import core._
-import Symbols._, Types._, Contexts._, Names._, StdNames._, Constants._, SymUtils._
-import scala.collection.{ mutable, immutable }
+import Symbols._, Types._, Contexts._, StdNames._, Constants._, SymUtils._
 import Flags._
-import MegaPhase._
 import DenotTransformers._
-import ast.Trees._
-import ast.untpd
 import Decorators._
 import NameOps._
 import Annotations.Annotation
 import ValueClasses.isDerivedValueClass
-import scala.collection.mutable.ListBuffer
-import scala.language.postfixOps
 
 /** Synthetic method implementations for case classes, case objects,
  *  and value classes.
@@ -52,9 +46,9 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
       myCaseModuleSymbols = myCaseSymbols.filter(_ ne defn.Any_equals)
     }
 
-  def valueSymbols(implicit ctx: Context) = { initSymbols; myValueSymbols }
-  def caseSymbols(implicit ctx: Context) = { initSymbols; myCaseSymbols }
-  def caseModuleSymbols(implicit ctx: Context) = { initSymbols; myCaseModuleSymbols }
+  def valueSymbols(implicit ctx: Context): List[Symbol] = { initSymbols; myValueSymbols }
+  def caseSymbols(implicit ctx: Context): List[Symbol] = { initSymbols; myCaseSymbols }
+  def caseModuleSymbols(implicit ctx: Context): List[Symbol] = { initSymbols; myCaseModuleSymbols }
 
   /** The synthetic methods of the case or value class `clazz`. */
   def syntheticMethods(clazz: ClassSymbol)(implicit ctx: Context): List[Tree] = {
@@ -264,7 +258,7 @@ class SyntheticMethods(thisPhase: DenotTransformer) {
     symbolsToSynthesize flatMap syntheticDefIfMissing
   }
 
-  def addSyntheticMethods(impl: Template)(implicit ctx: Context) =
+  def addSyntheticMethods(impl: Template)(implicit ctx: Context): Template =
     if (ctx.owner.is(Case) || isDerivedValueClass(ctx.owner))
       cpy.Template(impl)(body = impl.body ++ syntheticMethods(ctx.owner.asClass))
     else
diff --git a/compiler/src/dotty/tools/dotc/transform/TailRec.scala b/compiler/src/dotty/tools/dotc/transform/TailRec.scala
index 405e3dd25cb7..bde3d80b98ce 100644
--- a/compiler/src/dotty/tools/dotc/transform/TailRec.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TailRec.scala
@@ -12,7 +12,6 @@ import Types._
 import NameKinds.TailLabelName
 import MegaPhase.MiniPhase
 import reporting.diagnostic.messages.TailrecNotApplicable
-import util.Property
 
 /**
  * A Tail Rec Transformer
@@ -71,9 +70,9 @@ class TailRec extends MiniPhase {
 
   override def phaseName: String = TailRec.name
 
-  override def runsAfter = Set(Erasure.name) // tailrec assumes erased types
+  override def runsAfter: Set[String] = Set(Erasure.name) // tailrec assumes erased types
 
-  final val labelFlags = Flags.Synthetic | Flags.Label | Flags.Method
+  final val labelFlags: Flags.FlagSet = Flags.Synthetic | Flags.Label | Flags.Method
 
   private def mkLabel(method: Symbol)(implicit ctx: Context): TermSymbol = {
     val name = TailLabelName.fresh()
@@ -179,7 +178,7 @@ class TailRec extends MiniPhase {
 
     import dotty.tools.dotc.ast.tpd._
 
-    var rewrote = false
+    var rewrote: Boolean = false
 
     /** Symbols of Labeled blocks that are in tail position. */
     private val tailPositionLabeledSyms = new collection.mutable.HashSet[Symbol]()
@@ -339,10 +338,10 @@ class TailRec extends MiniPhase {
 }
 
 object TailRec {
-  val name = "tailrec"
+  val name: String = "tailrec"
 
   final class TailContext(val tailPos: Boolean) extends AnyVal
 
-  final val noTailContext = new TailContext(false)
-  final val yesTailContext = new TailContext(true)
+  final val noTailContext: TailRec.TailContext = new TailContext(false)
+  final val yesTailContext: TailRec.TailContext = new TailContext(true)
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/TransformByNameApply.scala b/compiler/src/dotty/tools/dotc/transform/TransformByNameApply.scala
index 1e8aa9c72278..dc9317f0028a 100644
--- a/compiler/src/dotty/tools/dotc/transform/TransformByNameApply.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TransformByNameApply.scala
@@ -26,10 +26,10 @@ abstract class TransformByNameApply extends MiniPhase { thisPhase: DenotTransfor
     tree.symbol.denot(ctx.withPhase(thisPhase))
 
   /** If denotation had an ExprType before, it now gets a function type */
-  protected def exprBecomesFunction(symd: SymDenotation)(implicit ctx: Context) =
+  protected def exprBecomesFunction(symd: SymDenotation)(implicit ctx: Context): Boolean =
     (symd is Param) || (symd is (ParamAccessor, butNot = Method))
 
-  protected def isByNameRef(tree: Tree)(implicit ctx: Context) = {
+  protected def isByNameRef(tree: Tree)(implicit ctx: Context): Boolean = {
     val origDenot = originalDenotation(tree)
     origDenot.info.isInstanceOf[ExprType] && exprBecomesFunction(origDenot)
   }
diff --git a/compiler/src/dotty/tools/dotc/transform/TransformWildcards.scala b/compiler/src/dotty/tools/dotc/transform/TransformWildcards.scala
index be813dbeea90..316aff6cac5e 100644
--- a/compiler/src/dotty/tools/dotc/transform/TransformWildcards.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TransformWildcards.scala
@@ -14,7 +14,7 @@ import ast.tpd
 class TransformWildcards extends MiniPhase with IdentityDenotTransformer {
   import tpd._
 
-  override def phaseName = "transformWildcards"
+  override def phaseName: String = "transformWildcards"
 
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = {
     tree match {
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index d46d2dbcc510..8b1e7dd1397d 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -1,37 +1,27 @@
 package dotty.tools.dotc
 package transform
 
-import MegaPhase._
 import core.Names.Name
 import core.DenotTransformers._
-import core.Denotations._
 import core.SymDenotations._
 import core.Contexts._
 import core.Symbols._
 import core.Types._
 import core.Flags._
-import core.Constants._
 import core.StdNames._
-import core.NameOps._
 import core.NameKinds.{DocArtifactName, OuterSelectName}
 import core.Decorators._
-import core.TypeErasure.isErasedType
 import core.Phases.Phase
 import core.Mode
-import SymUtils._
 import typer._
 import typer.ErrorReporting._
 import reporting.ThrowingReporter
 import ast.Trees._
 import ast.{tpd, untpd}
-import util.SourcePosition
 import util.Chars._
 import collection.mutable
 import ProtoTypes._
-import config.Printers
-import java.lang.AssertionError
 
-import dotty.tools.dotc.core.Names
 
 import scala.util.control.NonFatal
 
@@ -52,13 +42,13 @@ class TreeChecker extends Phase with SymTransformer {
   private val seenClasses = collection.mutable.HashMap[String, Symbol]()
   private val seenModuleVals = collection.mutable.HashMap[String, Symbol]()
 
-  def isValidJVMName(name: Name) = name.toString.forall(isValidJVMChar)
+  def isValidJVMName(name: Name): Boolean = name.toString.forall(isValidJVMChar)
 
-  def isValidJVMMethodName(name: Name) = name.toString.forall(isValidJVMMethodChar)
+  def isValidJVMMethodName(name: Name): Boolean = name.toString.forall(isValidJVMMethodChar)
 
-  val NoSuperClass = Trait | Package
+  val NoSuperClass: FlagSet = Trait | Package
 
-  def testDuplicate(sym: Symbol, registry: mutable.Map[String, Symbol], typ: String)(implicit ctx: Context) = {
+  def testDuplicate(sym: Symbol, registry: mutable.Map[String, Symbol], typ: String)(implicit ctx: Context): Unit = {
     val name = sym.fullName.mangledString
     val isDuplicate = this.flatClasses && registry.contains(name)
     assert(!isDuplicate, s"$typ defined twice $sym ${sym.id} ${registry(name).id}")
@@ -116,7 +106,7 @@ class TreeChecker extends Phase with SymTransformer {
       Nil
   }
 
-  def check(phasesToRun: Seq[Phase], ctx: Context) = {
+  def check(phasesToRun: Seq[Phase], ctx: Context): Tree = {
     val prevPhase = ctx.phase.prev // can be a mini-phase
     val squahsedPhase = ctx.base.squashed(prevPhase)
     ctx.echo(s"checking ${ctx.compilationUnit} after phase ${squahsedPhase}")
@@ -140,13 +130,13 @@ class TreeChecker extends Phase with SymTransformer {
 
   class Checker(phasesToCheck: Seq[Phase]) extends ReTyper with Checking {
 
-    val nowDefinedSyms = new mutable.HashSet[Symbol]
-    val everDefinedSyms = newMutableSymbolMap[untpd.Tree]
+    private[this] val nowDefinedSyms: mutable.HashSet[Symbol] = new mutable.HashSet[Symbol]
+    private[this] val everDefinedSyms: MutableSymbolMap[untpd.Tree] = newMutableSymbolMap[untpd.Tree]
 
     // don't check value classes after typer, as the constraint about constructors doesn't hold after transform
-    override def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context) = ()
+    override def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context): Unit = ()
 
-    def withDefinedSyms[T](trees: List[untpd.Tree])(op: => T)(implicit ctx: Context) = {
+    def withDefinedSyms[T](trees: List[untpd.Tree])(op: => T)(implicit ctx: Context): T = {
       var locally = List.empty[Symbol]
       for (tree <- trees) {
         val sym = tree.symbol
@@ -181,14 +171,14 @@ class TreeChecker extends Phase with SymTransformer {
       res
     }
 
-    def withPatSyms[T](syms: List[Symbol])(op: => T)(implicit ctx: Context) = {
+    def withPatSyms[T](syms: List[Symbol])(op: => T)(implicit ctx: Context): T = {
       nowDefinedSyms ++= syms
       val res = op
       nowDefinedSyms --= syms
       res
     }
 
-    def assertDefined(tree: untpd.Tree)(implicit ctx: Context) =
+    def assertDefined(tree: untpd.Tree)(implicit ctx: Context): Unit =
       if (
         tree.symbol.maybeOwner.isTerm &&
         !(tree.symbol.is(Label | Method) && !tree.symbol.owner.isClass && ctx.phase.labelsReordered) // labeldefs breaks scoping
@@ -263,16 +253,16 @@ class TreeChecker extends Phase with SymTransformer {
      *  made `private` in phase `UnlinkErasedDecls`. These symbols will be removed
      *  completely in phase `Erasure` if they are defined in a currently compiled unit.
      */
-    override def excludeFromDoubleDeclCheck(sym: Symbol)(implicit ctx: Context) =
+    override def excludeFromDoubleDeclCheck(sym: Symbol)(implicit ctx: Context): Boolean =
       sym.isEffectivelyErased && sym.is(Private) && !sym.initial.is(Private)
 
-    override def typed(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): tpd.Tree = {
+    override def typed(tree: untpd.Tree, pt: Type = WildcardType)(implicit ctx: Context): Tree = {
       val tpdTree = super.typed(tree, pt)
       checkIdentNotJavaClass(tpdTree)
       tpdTree
     }
 
-    override def typedUnadapted(tree: untpd.Tree, pt: Type, locked: TypeVars)(implicit ctx: Context): tpd.Tree = {
+    override def typedUnadapted(tree: untpd.Tree, pt: Type, locked: TypeVars)(implicit ctx: Context): Tree = {
       val res = tree match {
         case _: untpd.TypedSplice | _: untpd.Thicket | _: EmptyValDef[_] =>
           super.typedUnadapted(tree, pt, locked)
@@ -356,7 +346,7 @@ class TreeChecker extends Phase with SymTransformer {
       checkNotRepeated(super.typedSelect(tree, pt))
     }
 
-    override def typedThis(tree: untpd.This)(implicit ctx: Context) = {
+    override def typedThis(tree: untpd.This)(implicit ctx: Context): Tree = {
       val res = super.typedThis(tree)
       val cls = res.symbol
       assert(cls.isStaticOwner || ctx.owner.isContainedIn(cls), i"error while typing $tree, ${ctx.owner} is not contained in $cls")
@@ -373,7 +363,7 @@ class TreeChecker extends Phase with SymTransformer {
         i"owner chain = ${tree.symbol.ownersIterator.toList}%, %, ctxOwners = ${ctx.outersIterator.map(_.owner).toList}%, %")
     }
 
-    override def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(implicit ctx: Context) = {
+    override def typedClassDef(cdef: untpd.TypeDef, cls: ClassSymbol)(implicit ctx: Context): Tree = {
       val TypeDef(_, impl @ Template(constr, _, _, _)) = cdef
       assert(cdef.symbol == cls)
       assert(impl.symbol.owner == cls)
@@ -399,7 +389,7 @@ class TreeChecker extends Phase with SymTransformer {
       super.typedClassDef(cdef, cls)
     }
 
-    override def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context) =
+    override def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context): Tree =
       withDefinedSyms(ddef.tparams) {
         withDefinedSyms(ddef.vparamss.flatten) {
           if (!sym.isClassConstructor && !(sym.name eq nme.STATIC_CONSTRUCTOR))
@@ -424,10 +414,10 @@ class TreeChecker extends Phase with SymTransformer {
       }
     }
 
-    override def typedBlock(tree: untpd.Block, pt: Type)(implicit ctx: Context) =
+    override def typedBlock(tree: untpd.Block, pt: Type)(implicit ctx: Context): Tree =
       withDefinedSyms(tree.stats) { super.typedBlock(tree, pt) }
 
-    override def typedInlined(tree: untpd.Inlined, pt: Type)(implicit ctx: Context) =
+    override def typedInlined(tree: untpd.Inlined, pt: Type)(implicit ctx: Context): Tree =
       withDefinedSyms(tree.bindings) { super.typedInlined(tree, pt) }
 
     /** Check that all defined symbols have legal owners.
@@ -465,7 +455,7 @@ class TreeChecker extends Phase with SymTransformer {
     override def ensureNoLocalRefs(tree: Tree, pt: Type, localSyms: => List[Symbol])(implicit ctx: Context): Tree =
       tree
 
-    override def adapt(tree: Tree, pt: Type, locked: TypeVars)(implicit ctx: Context) = {
+    override def adapt(tree: Tree, pt: Type, locked: TypeVars)(implicit ctx: Context): Tree = {
       def isPrimaryConstructorReturn =
         ctx.owner.isPrimaryConstructor && pt.isRef(ctx.owner.owner) && tree.tpe.isRef(defn.UnitClass)
       if (ctx.mode.isExpr &&
@@ -487,13 +477,13 @@ class TreeChecker extends Phase with SymTransformer {
   /**
     * Checks that `New` nodes are always wrapped inside `Select` nodes.
     */
-  def assertSelectWrapsNew(tree: tpd.Tree)(implicit ctx: Context): Unit = {
+  def assertSelectWrapsNew(tree: Tree)(implicit ctx: Context): Unit = {
     (new TreeAccumulator[tpd.Tree] {
-      override def apply(parent: tpd.Tree, tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = {
+      override def apply(parent: Tree, tree: Tree)(implicit ctx: Context): Tree = {
         tree match {
-          case tree: tpd.New if !parent.isInstanceOf[tpd.Select] =>
+          case tree: New if !parent.isInstanceOf[tpd.Select] =>
             assert(assertion = false, i"`New` node must be wrapped in a `Select`:\n  parent = ${parent.show}\n  child = ${tree.show}")
-          case _: tpd.Annotated =>
+          case _: Annotated =>
             // Don't check inside annotations, since they're allowed to contain
             // somewhat invalid trees.
           case _ =>
@@ -509,7 +499,7 @@ object TreeChecker {
   /** - Check that TypeParamRefs and MethodParams refer to an enclosing type.
    *  - Check that all type variables are instantiated.
    */
-  def checkNoOrphans(tp0: Type, tree: untpd.Tree = untpd.EmptyTree)(implicit ctx: Context) = new TypeMap() {
+  def checkNoOrphans(tp0: Type, tree: untpd.Tree = untpd.EmptyTree)(implicit ctx: Context): Type = new TypeMap() {
     val definedBinders = new java.util.IdentityHashMap[Type, Any]
     def apply(tp: Type): Type = {
       tp match {
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeExtractors.scala b/compiler/src/dotty/tools/dotc/transform/TreeExtractors.scala
index 680f21bff1ac..38dd28be2f16 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeExtractors.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeExtractors.scala
@@ -2,8 +2,8 @@ package dotty.tools.dotc
 package transform
 
 import ast.{Trees, tpd}
-import core._, core.Decorators._
-import Contexts._, Flags._, Trees._, Types._, StdNames._, Symbols._
+import core._
+import Contexts._, Trees._, Types._, StdNames._, Symbols._
 import ValueClasses._
 
 object TreeExtractors {
diff --git a/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala b/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala
index 530b1a39a92c..827b2bd6c57e 100644
--- a/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TryCatchPatterns.scala
@@ -6,7 +6,6 @@ import core.StdNames._
 import ast.Trees._
 import core.Types._
 import core.NameKinds.ExceptionBinderName
-import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Contexts.Context
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
@@ -45,7 +44,7 @@ class TryCatchPatterns extends MiniPhase {
 
   def phaseName: String = "tryCatchPatterns"
 
-  override def runsAfter = Set(ElimRepeated.name)
+  override def runsAfter: Set[String] = Set(ElimRepeated.name)
 
   override def checkPostCondition(tree: Tree)(implicit ctx: Context): Unit = tree match {
     case Try(_, cases, _) =>
diff --git a/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala b/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala
index d1e7dce35c53..4239b8248c10 100644
--- a/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala
@@ -6,10 +6,6 @@ import TypeErasure.ErasedValueType
 import Types._
 import Contexts._
 import Symbols._
-import Decorators._
-import StdNames.nme
-import NameOps._
-import language.implicitConversions
 
 object TypeUtils {
   /** A decorator that provides methods on types
diff --git a/compiler/src/dotty/tools/dotc/transform/VCElideAllocations.scala b/compiler/src/dotty/tools/dotc/transform/VCElideAllocations.scala
index 2ba909733ba3..711c24aa7c06 100644
--- a/compiler/src/dotty/tools/dotc/transform/VCElideAllocations.scala
+++ b/compiler/src/dotty/tools/dotc/transform/VCElideAllocations.scala
@@ -1,11 +1,11 @@
 package dotty.tools.dotc
 package transform
 
-import ast.{Trees, tpd}
-import core._, core.Decorators._
-import Contexts._, Trees._, StdNames._, Symbols._
-import DenotTransformers._, MegaPhase._, Phases.Phase
-import ExtensionMethods._, TreeExtractors._, ValueClasses._
+import ast.tpd
+import core._
+import Contexts._, Symbols._
+import DenotTransformers._, MegaPhase._
+import TreeExtractors._, ValueClasses._
 
 /** This phase elides unnecessary value class allocations
  *
@@ -20,7 +20,7 @@ class VCElideAllocations extends MiniPhase with IdentityDenotTransformer {
 
   override def phaseName: String = "vcElideAllocations"
 
-  override def runsAfter = Set(ElimErasedValueType.name)
+  override def runsAfter: Set[String] = Set(ElimErasedValueType.name)
 
   override def transformApply(tree: Apply)(implicit ctx: Context): Tree =
     tree match {
diff --git a/compiler/src/dotty/tools/dotc/transform/VCInlineMethods.scala b/compiler/src/dotty/tools/dotc/transform/VCInlineMethods.scala
index 2a526ebe3ae3..7f5097fd5d27 100644
--- a/compiler/src/dotty/tools/dotc/transform/VCInlineMethods.scala
+++ b/compiler/src/dotty/tools/dotc/transform/VCInlineMethods.scala
@@ -2,12 +2,11 @@ package dotty.tools.dotc
 package transform
 
 import ast.{Trees, tpd}
-import core._, core.Decorators._
+import core._
 import Contexts._, Trees._, Types._
-import DenotTransformers._, MegaPhase._, Phases.Phase
+import DenotTransformers._, MegaPhase._
 import ExtensionMethods._, ValueClasses._
 
-import collection.mutable.ListBuffer
 
 /** This phase inlines calls to methods of value classes.
  *
@@ -44,7 +43,7 @@ class VCInlineMethods extends MiniPhase with IdentityDenotTransformer {
 
   override def phaseName: String = "vcInlineMethods"
 
-  override def runsAfter =
+  override def runsAfter: Set[String] =
     Set(ExtensionMethods.name, PatternMatcher.name)
 
   /** Replace a value class method call by a call to the corresponding extension method.
diff --git a/compiler/src/dotty/tools/dotc/transform/ValueClasses.scala b/compiler/src/dotty/tools/dotc/transform/ValueClasses.scala
index 120424204274..311eb184824f 100644
--- a/compiler/src/dotty/tools/dotc/transform/ValueClasses.scala
+++ b/compiler/src/dotty/tools/dotc/transform/ValueClasses.scala
@@ -21,7 +21,7 @@ object ValueClasses {
     !d.isPrimitiveValueClass
   }
 
-  def isMethodWithExtension(sym: Symbol)(implicit ctx: Context) =
+  def isMethodWithExtension(sym: Symbol)(implicit ctx: Context): Boolean =
     ctx.atPhaseNotLaterThan(ctx.extensionMethodsPhase) { implicit ctx =>
       val d = sym.denot
       d.validFor.containsPhaseId(ctx.phaseId) &&
diff --git a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
index 7c34df04ab05..8077b3993e0a 100644
--- a/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
+++ b/compiler/src/dotty/tools/dotc/transform/patmat/Space.scala
@@ -355,7 +355,7 @@ class SpaceEngine(implicit ctx: Context) extends SpaceLogic {
   }
 
   /* Erase pattern bound types with WildcardType */
-  def erase(tp: Type) = {
+  def erase(tp: Type): Type = {
     def isPatternTypeSymbol(sym: Symbol) = !sym.isClass && sym.is(Case)
 
     val map = new TypeMap {
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index bb2f292cf772..ee45d93ae532 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -3,21 +3,17 @@ package dotc
 package typer
 
 import core._
-import ast.{TreeInfo, Trees, tpd, untpd}
+import ast.{Trees, tpd, untpd}
 import util.Positions._
 import util.Stats.track
 import Trees.Untyped
-import Mode.ImplicitsEnabled
 import Contexts._
 import Flags._
-import Denotations._
-import NameOps._
 import Symbols._
 import Types._
 import Decorators._
 import ErrorReporting._
 import Trees._
-import config.Config
 import Names._
 import StdNames._
 import NameKinds.DefaultGetterName
@@ -28,21 +24,19 @@ import collection.mutable
 import config.Printers.{overload, typr, unapp}
 import TypeApplications._
 
-import language.implicitConversions
 import reporting.diagnostic.Message
 import reporting.trace
 import Constants.{Constant, IntTag, LongTag}
 import dotty.tools.dotc.reporting.diagnostic.messages.{NotAnExtractor, UnapplyInvalidNumberOfArguments}
-
-import scala.collection.mutable.ListBuffer
+import Denotations.SingleDenotation
 
 object Applications {
   import tpd._
 
-  def extractorMember(tp: Type, name: Name)(implicit ctx: Context) =
+  def extractorMember(tp: Type, name: Name)(implicit ctx: Context): SingleDenotation =
     tp.member(name).suchThat(_.info.isParameterless)
 
-  def extractorMemberType(tp: Type, name: Name, errorPos: Position = NoPosition)(implicit ctx: Context) = {
+  def extractorMemberType(tp: Type, name: Name, errorPos: Position = NoPosition)(implicit ctx: Context): Type = {
     val ref = extractorMember(tp, name)
     if (ref.isOverloaded)
       errorType(i"Overloaded reference to $ref is not allowed in extractor", errorPos)
@@ -53,14 +47,14 @@ object Applications {
    *  for a pattern with `numArgs` subpatterns?
    *  This is the case of `tp` has members `_1` to `_N` where `N == numArgs`.
    */
-  def isProductMatch(tp: Type, numArgs: Int)(implicit ctx: Context) =
+  def isProductMatch(tp: Type, numArgs: Int)(implicit ctx: Context): Boolean =
     numArgs > 0 && productArity(tp) == numArgs
 
   /** Does `tp` fit the "get match" conditions as an unapply result type?
    *  This is the case of `tp` has a `get` member as well as a
    *  parameterless `isEmpty` member of result type `Boolean`.
    */
-  def isGetMatch(tp: Type, errorPos: Position = NoPosition)(implicit ctx: Context) =
+  def isGetMatch(tp: Type, errorPos: Position = NoPosition)(implicit ctx: Context): Boolean =
     extractorMemberType(tp, nme.isEmpty, errorPos).isRef(defn.BooleanClass) &&
     extractorMemberType(tp, nme.get, errorPos).exists
 
@@ -69,7 +63,7 @@ object Applications {
     sels.takeWhile(_.exists).toList
   }
 
-  def productArity(tp: Type)(implicit ctx: Context) =
+  def productArity(tp: Type)(implicit ctx: Context): Int =
     if (defn.isProductSubType(tp)) productSelectorTypes(tp).size else -1
 
   def productSelectors(tp: Type)(implicit ctx: Context): List[Symbol] = {
@@ -161,14 +155,12 @@ object Applications {
     if (defs != null && defs.nonEmpty) tpd.Block(defs.toList, tree) else tree
 }
 
-import Applications._
 
 trait Applications extends Compatibility { self: Typer with Dynamic =>
 
   import Applications._
   import tpd.{ cpy => _, _ }
   import untpd.cpy
-  import Dynamic.isDynamicMethod
 
   /** @tparam Arg       the type of arguments, could be tpd.Tree, untpd.Tree, or Type
    *  @param methRef    the reference to the method of the application
@@ -249,8 +241,8 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     /** A flag signalling that the typechecking the application was so far successful */
     private[this] var _ok = true
 
-    def ok = _ok
-    def ok_=(x: Boolean) = {
+    def ok: Boolean = _ok
+    def ok_=(x: Boolean): Unit = {
       assert(x || ctx.reporter.errorsReported || !ctx.typerState.isCommittable) // !!! DEBUG
       _ok = x
     }
@@ -264,7 +256,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       case tp => tp //was: funType
     }
 
-    lazy val liftedFunType =
+    lazy val liftedFunType: Type =
       if (needLiftFun) {
         liftFun()
         normalizedFun.tpe
@@ -274,13 +266,13 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     /** The arguments re-ordered so that each named argument matches the
      *  same-named formal parameter.
      */
-    lazy val orderedArgs =
+    lazy val orderedArgs: List[Arg] =
       if (hasNamedArg(args))
         reorder(args.asInstanceOf[List[untpd.Tree]]).asInstanceOf[List[Arg]]
       else
         args
 
-    protected def init() = methType match {
+    protected def init(): Unit = methType match {
       case methType: MethodType =>
         // apply the result type constraint, unless method type is dependent
         val resultApprox = resultTypeApprox(methType)
@@ -300,9 +292,9 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     }
 
     /** The application was successful */
-    def success = ok
+    def success: Boolean = ok
 
-    protected def methodType = methType.asInstanceOf[MethodType]
+    protected def methodType: MethodType = methType.asInstanceOf[MethodType]
     private def methString: String = i"${methRef.symbol}: ${methType.show}"
 
     /** Re-order arguments to correctly align named arguments */
@@ -458,7 +450,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     }
 
     /** Is `sym` a constructor of a Java-defined annotation? */
-    def isJavaAnnotConstr(sym: Symbol) =
+    def isJavaAnnotConstr(sym: Symbol): Boolean =
       sym.is(JavaDefined) && sym.isConstructor && sym.owner.derivesFrom(defn.AnnotationClass)
 
     /** Match re-ordered arguments against formal parameters
@@ -534,7 +526,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     type TypedArg = Arg
     type Result = Unit
 
-    protected def argOK(arg: TypedArg, formal: Type) = argType(arg, formal) match {
+    protected def argOK(arg: TypedArg, formal: Type): Boolean = argType(arg, formal) match {
       case ref: TermRef if ref.denot.isOverloaded =>
         // in this case we could not resolve overloading because no alternative
         // matches expected type
@@ -551,14 +543,14 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     protected def argType(arg: Arg, formal: Type): Type
 
     def typedArg(arg: Arg, formal: Type): Arg = arg
-    final def addArg(arg: TypedArg, formal: Type) = ok = ok & argOK(arg, formal)
-    def makeVarArg(n: Int, elemFormal: Type) = {}
-    def fail(msg: => Message, arg: Arg) =
+    final def addArg(arg: TypedArg, formal: Type): Unit = ok = ok & argOK(arg, formal)
+    def makeVarArg(n: Int, elemFormal: Type): Unit = {}
+    def fail(msg: => Message, arg: Arg): Unit =
       ok = false
-    def fail(msg: => Message) =
+    def fail(msg: => Message): Unit =
       ok = false
-    def appPos = NoPosition
-    lazy val normalizedFun = ref(methRef)
+    def appPos: Position = NoPosition
+    lazy val normalizedFun:   Tree = ref(methRef)
     init()
   }
 
@@ -571,14 +563,14 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     def treeToArg(arg: Tree): Tree = arg
     def isVarArg(arg: Tree): Boolean = tpd.isWildcardStarArg(arg)
     def typeOfArg(arg: Tree): Type = arg.tpe
-    def harmonizeArgs(args: List[Tree]) = harmonize(args)
+    def harmonizeArgs(args: List[Tree]): List[Tree] = harmonize(args)
   }
 
   /** Subclass of Application for applicability tests with type arguments and value
    * argument trees.
    */
   class ApplicableToTreesDirectly(methRef: TermRef, targs: List[Type], args: List[Tree], resultType: Type)(implicit ctx: Context) extends ApplicableToTrees(methRef, targs, args, resultType)(ctx) {
-    override def argOK(arg: TypedArg, formal: Type) = argType(arg, formal) <:< formal
+    override def argOK(arg: TypedArg, formal: Type): Boolean = argType(arg, formal) <:< formal
   }
 
   /** Subclass of Application for applicability tests with value argument types. */
@@ -588,7 +580,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     def treeToArg(arg: Tree): Type = arg.tpe
     def isVarArg(arg: Type): Boolean = arg.isRepeatedParam
     def typeOfArg(arg: Type): Type = arg
-    def harmonizeArgs(args: List[Type]) = harmonizeTypes(args)
+    def harmonizeArgs(args: List[Type]): List[Type] = harmonizeTypes(args)
   }
 
   /** Subclass of Application for type checking an Apply node, where
@@ -614,21 +606,21 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       typedArgBuf += seqToRepeated(SeqLiteral(args, elemtpt))
     }
 
-    def harmonizeArgs(args: List[TypedArg]) = harmonize(args)
+    def harmonizeArgs(args: List[TypedArg]): List[Tree] = harmonize(args)
 
-    override def appPos = app.pos
+    override def appPos: Position = app.pos
 
-    def fail(msg: => Message, arg: Trees.Tree[T]) = {
+    def fail(msg: => Message, arg: Trees.Tree[T]): Unit = {
       ctx.error(msg, arg.pos)
       ok = false
     }
 
-    def fail(msg: => Message) = {
+    def fail(msg: => Message): Unit = {
       ctx.error(msg, app.pos)
       ok = false
     }
 
-    def normalizedFun = myNormalizedFun
+    def normalizedFun:  Tree = myNormalizedFun
 
     private def lifter(implicit ctx: Context) =
       if (methRef.symbol.hasDefaultParams) LiftComplex else LiftImpure
@@ -656,7 +648,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     }
     private def sameSeq[T <: Trees.Tree[_]](xs: List[T], ys: List[T]): Boolean = firstDiff(xs, ys) < 0
 
-    val result = {
+    val result:   Tree = {
       var typedArgs = typedArgBuf.toList
       def app0 = cpy.Apply(app)(normalizedFun, typedArgs) // needs to be a `def` because typedArgs can change later
       val app1 =
@@ -703,7 +695,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
   extends TypedApply(app, fun, methRef, proto.args, resultType) {
     def typedArg(arg: untpd.Tree, formal: Type): TypedArg = proto.typedArg(arg, formal.widenExpr)
     def treeToArg(arg: Tree): untpd.Tree = untpd.TypedSplice(arg)
-    def typeOfArg(arg: untpd.Tree) = proto.typeOfArg(arg)
+    def typeOfArg(arg: untpd.Tree): Type = proto.typeOfArg(arg)
   }
 
   /** Subclass of Application for type checking an Apply node with typed arguments. */
@@ -713,9 +705,9 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       // (of both Scala and Dotty). Untyped is legal, and a subtype of Typed, whereas TypeApply
       // is invariant in the type parameter, so the minimal type should be inferred. But then typedArg does
       // not match the abstract method in Application and an abstract class error results.
-    def typedArg(arg: tpd.Tree, formal: Type): TypedArg = arg
+    def typedArg(arg:   Tree, formal: Type): TypedArg = arg
     def treeToArg(arg: Tree): Tree = arg
-    def typeOfArg(arg: Tree) = arg.tpe
+    def typeOfArg(arg: Tree): Type = arg.tpe
   }
 
   /** If `app` is a `this(...)` constructor call, the this-call argument context,
@@ -853,7 +845,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
   protected def handleUnexpectedFunType(tree: untpd.Apply, fun: Tree)(implicit ctx: Context): Tree =
     throw new Error(i"unexpected type.\n  fun = $fun,\n  methPart(fun) = ${methPart(fun)},\n  methPart(fun).tpe = ${methPart(fun).tpe},\n  tpe = ${fun.tpe}")
 
-  def typedNamedArgs(args: List[untpd.Tree])(implicit ctx: Context) =
+  def typedNamedArgs(args: List[untpd.Tree])(implicit ctx: Context): List[NamedArg] =
     for (arg @ NamedArg(id, argtpt) <- args) yield {
       val argtpt1 = typedType(argtpt)
       cpy.NamedArg(arg)(id, argtpt1).withType(argtpt1.tpe)
@@ -884,7 +876,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
    *  It is performed during typer as creation of generic arrays needs a classTag.
    *  we rely on implicit search to find one.
    */
-  def convertNewGenericArray(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
+  def convertNewGenericArray(tree:  Tree)(implicit ctx: Context):  Tree = tree match {
     case Apply(TypeApply(tycon, targs@(targ :: Nil)), args) if tycon.symbol == defn.ArrayConstructor =>
       fullyDefinedType(tree.tpe, "array", tree.pos)
 
@@ -1605,7 +1597,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
    *  the result of harmomization will be compared again with the expected type.
    *  Test cases where this matters are in pos/harmomize.scala.
    */
-  def harmonic[T](harmonize: List[T] => List[T])(op: => List[T])(implicit ctx: Context) = {
+  def harmonic[T](harmonize: List[T] => List[T])(op: => List[T])(implicit ctx: Context): List[T] = {
     val origConstraint = ctx.typerState.constraint
     val origElems = op
     val harmonizedElems = harmonize(origElems)
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
index 42a48f09c451..a80e88ac61ce 100644
--- a/compiler/src/dotty/tools/dotc/typer/Checking.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -64,7 +64,7 @@ object Checking {
    *     Unreducible applications correspond to general existentials, and we
    *     cannot handle those.
    */
-  def checkAppliedType(tree: AppliedTypeTree, boundsCheck: Boolean)(implicit ctx: Context) = {
+  def checkAppliedType(tree: AppliedTypeTree, boundsCheck: Boolean)(implicit ctx: Context): Unit = {
     val AppliedTypeTree(tycon, args) = tree
     // If `args` is a list of named arguments, return corresponding type parameters,
     // otherwise return type parameters unchanged
@@ -507,7 +507,7 @@ object Checking {
   }
 
   /** Verify classes extending AnyVal meet the requirements */
-  def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context) = {
+  def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context): Unit = {
     def checkValueClassMember(stat: Tree) = stat match {
       case _: TypeDef if stat.symbol.isClass =>
         ctx.error(ValueClassesMayNotDefineInner(clazz, stat.symbol), stat.pos)
@@ -698,7 +698,7 @@ trait Checking {
   }
 
   /** A hook to exclude selected symbols from double declaration check */
-  def excludeFromDoubleDeclCheck(sym: Symbol)(implicit ctx: Context) = false
+  def excludeFromDoubleDeclCheck(sym: Symbol)(implicit ctx: Context): Boolean = false
 
   /** Check that class does not declare same symbol twice */
   def checkNoDoubleDeclaration(cls: Symbol)(implicit ctx: Context): Unit = {
@@ -733,7 +733,7 @@ trait Checking {
     }
   }
 
-  def checkParentCall(call: Tree, caller: ClassSymbol)(implicit ctx: Context) =
+  def checkParentCall(call: Tree, caller: ClassSymbol)(implicit ctx: Context): Unit =
     if (!ctx.isAfterTyper) {
       val called = call.tpe.classSymbol
       if (caller is Trait)
@@ -758,7 +758,7 @@ trait Checking {
     else tpt
 
   /** Verify classes extending AnyVal meet the requirements */
-  def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context) =
+  def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context): Unit =
     Checking.checkDerivedValueClass(clazz, stats)
 
   /** Given a parent `parent` of a class `cls`, if `parent` is a trait check that
@@ -862,7 +862,7 @@ trait Checking {
   }
 
   /** Check that we are in an inline context (inside an inline method or in inline code) */
-  def checkInInlineContext(what: String, pos: Position)(implicit ctx: Context) =
+  def checkInInlineContext(what: String, pos: Position)(implicit ctx: Context): Unit =
     if (!ctx.inInlineMethod && !ctx.isInlineContext)
       ctx.error(em"$what can only be used in an inline method", pos)
 
@@ -967,16 +967,16 @@ trait NoChecking extends ReChecking {
   override def checkImplicitConversionDefOK(sym: Symbol)(implicit ctx: Context): Unit = ()
   override def checkImplicitConversionUseOK(sym: Symbol, pos: Position)(implicit ctx: Context): Unit = ()
   override def checkFeasibleParent(tp: Type, pos: Position, where: => String = "")(implicit ctx: Context): Type = tp
-  override def checkInlineConformant(tree: Tree, isFinal: Boolean, what: => String)(implicit ctx: Context) = ()
+  override def checkInlineConformant(tree: Tree, isFinal: Boolean, what: => String)(implicit ctx: Context): Unit = ()
   override def checkNoDoubleDeclaration(cls: Symbol)(implicit ctx: Context): Unit = ()
-  override def checkParentCall(call: Tree, caller: ClassSymbol)(implicit ctx: Context) = ()
+  override def checkParentCall(call: Tree, caller: ClassSymbol)(implicit ctx: Context): Unit = ()
   override def checkSimpleKinded(tpt: Tree)(implicit ctx: Context): Tree = tpt
   override def checkNotSingleton(tpt: Tree, where: String)(implicit ctx: Context): Tree = tpt
-  override def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context) = ()
-  override def checkTraitInheritance(parentSym: Symbol, cls: ClassSymbol, pos: Position)(implicit ctx: Context) = ()
-  override def checkCaseInheritance(parentSym: Symbol, caseCls: ClassSymbol, pos: Position)(implicit ctx: Context) = ()
+  override def checkDerivedValueClass(clazz: Symbol, stats: List[Tree])(implicit ctx: Context): Unit = ()
+  override def checkTraitInheritance(parentSym: Symbol, cls: ClassSymbol, pos: Position)(implicit ctx: Context): Unit = ()
+  override def checkCaseInheritance(parentSym: Symbol, caseCls: ClassSymbol, pos: Position)(implicit ctx: Context): Unit = ()
   override def checkNoForwardDependencies(vparams: List[ValDef])(implicit ctx: Context): Unit = ()
   override def checkMembersOK(tp: Type, pos: Position)(implicit ctx: Context): Type = tp
-  override def checkInInlineContext(what: String, pos: Position)(implicit ctx: Context) = ()
+  override def checkInInlineContext(what: String, pos: Position)(implicit ctx: Context): Unit = ()
   override def checkFeature(base: ClassSymbol, name: TermName, description: => String, featureUseSite: Symbol, pos: Position)(implicit ctx: Context): Unit = ()
 }
diff --git a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
index e14b7f122b6e..d1ee5da0957f 100644
--- a/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Dynamic.scala
@@ -14,7 +14,6 @@ import dotty.tools.dotc.core.Decorators._
 import util.Positions._
 import core.Symbols._
 import core.Definitions
-import Inferencing._
 import ErrorReporting._
 import dotty.tools.dotc.reporting.diagnostic.messages.ReassignmentToVal
 
diff --git a/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala b/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala
index 923425800e93..f2c42f05262e 100644
--- a/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala
@@ -26,7 +26,7 @@ object ErrorReporting {
     ErrorType(msg)
   }
 
-  def wrongNumberOfTypeArgs(fntpe: Type, expectedArgs: List[ParamInfo], actual: List[untpd.Tree], pos: Position)(implicit ctx: Context) =
+  def wrongNumberOfTypeArgs(fntpe: Type, expectedArgs: List[ParamInfo], actual: List[untpd.Tree], pos: Position)(implicit ctx: Context): ErrorType =
     errorType(WrongNumberOfTypeArgs(fntpe, expectedArgs, actual)(ctx), pos)
 
   class Errors(implicit ctx: Context) {
@@ -51,7 +51,7 @@ object ErrorReporting {
         em"expected type $tp"
     }
 
-    def anonymousTypeMemberStr(tpe: Type) = {
+    def anonymousTypeMemberStr(tpe: Type): String = {
       val kind = tpe match {
           case _: TypeBounds => "type with bounds"
           case _: MethodOrPoly => "method"
@@ -60,7 +60,7 @@ object ErrorReporting {
         em"$kind $tpe"
     }
 
-    def overloadedAltsStr(alts: List[SingleDenotation]) =
+    def overloadedAltsStr(alts: List[SingleDenotation]): String =
       em"overloaded alternatives of ${denotStr(alts.head)} with types\n" +
       em" ${alts map (_.info)}%\n %"
 
@@ -76,7 +76,7 @@ object ErrorReporting {
 
     def exprStr(tree: Tree): String = refStr(tree.tpe)
 
-    def takesNoParamsStr(tree: Tree, kind: String) =
+    def takesNoParamsStr(tree: Tree, kind: String): String =
       if (tree.tpe.widen.exists)
         i"${exprStr(tree)} does not take ${kind}parameters"
       else
@@ -92,7 +92,7 @@ object ErrorReporting {
     }
 
     /** A subtype log explaining why `found` does not conform to `expected` */
-    def whyNoMatchStr(found: Type, expected: Type) = {
+    def whyNoMatchStr(found: Type, expected: Type): String = {
       def dropJavaMethod(tp: Type): Type = tp match {
         case tp: PolyType =>
           tp.derivedLambdaType(resType = dropJavaMethod(tp.resultType))
@@ -113,7 +113,7 @@ object ErrorReporting {
         ""
     }
 
-    def typeMismatchMsg(found: Type, expected: Type, postScript: String = "") = {
+    def typeMismatchMsg(found: Type, expected: Type, postScript: String = ""): TypeMismatch = {
       // replace constrained TypeParamRefs and their typevars by their bounds where possible
       // the idea is that if the bounds are also not-subtypes of each other to report
       // the type mismatch on the bounds instead of the original TypeParamRefs, since
diff --git a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
index 3418f83f9d40..7b40b854edcc 100644
--- a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
+++ b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
@@ -3,17 +3,14 @@ package dotc
 package typer
 
 import core._
-import ast.{Trees, untpd, tpd, TreeInfo}
+import ast.{Trees, untpd, tpd}
 import Contexts._
 import Types._
 import Flags._
-import NameOps._
 import Symbols._
-import Decorators._
 import Names._
 import StdNames._
 import NameKinds.UniqueName
-import Inferencing._
 import util.Positions._
 import collection.mutable
 import Trees._
@@ -80,7 +77,7 @@ abstract class Lifter {
   /** Lift arguments that are not-idempotent into ValDefs in buffer `defs`
    *  and replace by the idents of so created ValDefs.
    */
-  def liftArgs(defs: mutable.ListBuffer[Tree], methRef: Type, args: List[Tree])(implicit ctx: Context) =
+  def liftArgs(defs: mutable.ListBuffer[Tree], methRef: Type, args: List[Tree])(implicit ctx: Context): List[Tree] =
     methRef.widen match {
       case mt: MethodType =>
         (args, mt.paramNames, mt.paramInfos).zipped.map { (arg, name, tp) =>
@@ -134,26 +131,26 @@ abstract class Lifter {
 
 /** No lifting at all */
 object NoLift extends Lifter {
-  def noLift(expr: tpd.Tree)(implicit ctx: Context) = true
+  def noLift(expr: tpd.Tree)(implicit ctx: Context): Boolean = true
 }
 
 /** Lift all impure arguments */
 class LiftImpure extends Lifter {
-  def noLift(expr: tpd.Tree)(implicit ctx: Context) = tpd.isPureExpr(expr)
+  def noLift(expr: tpd.Tree)(implicit ctx: Context): Boolean = tpd.isPureExpr(expr)
 }
 object LiftImpure extends LiftImpure
 
 /** Lift all impure or complex arguments */
 class LiftComplex extends Lifter {
-  def noLift(expr: tpd.Tree)(implicit ctx: Context) = tpd.isSimplyPure(expr)
-  override def exprLifter = LiftToDefs
+  def noLift(expr: tpd.Tree)(implicit ctx: Context): Boolean = tpd.isSimplyPure(expr)
+  override def exprLifter: Lifter = LiftToDefs
 }
 object LiftComplex extends LiftComplex
 
 /** Lift all impure or complex arguments to `def`s */
 object LiftToDefs extends LiftComplex {
   override def liftedFlags: FlagSet = Method
-  override def liftedDef(sym: TermSymbol, rhs: tpd.Tree)(implicit ctx: Context) = tpd.DefDef(sym, rhs)
+  override def liftedDef(sym: TermSymbol, rhs: tpd.Tree)(implicit ctx: Context): tpd.DefDef = tpd.DefDef(sym, rhs)
 }
 
 /** Lifter for eta expansion */
diff --git a/compiler/src/dotty/tools/dotc/typer/FrontEnd.scala b/compiler/src/dotty/tools/dotc/typer/FrontEnd.scala
index ac4fa831dc18..ff65c5b87ef6 100644
--- a/compiler/src/dotty/tools/dotc/typer/FrontEnd.scala
+++ b/compiler/src/dotty/tools/dotc/typer/FrontEnd.scala
@@ -15,11 +15,11 @@ import ast.Trees._
 
 class FrontEnd extends Phase {
 
-  override def phaseName = FrontEnd.name
-  override def isTyper = true
+  override def phaseName: String = FrontEnd.name
+  override def isTyper: Boolean = true
   import ast.tpd
 
-  override def allowsImplicitSearch = true
+  override def allowsImplicitSearch: Boolean = true
 
   /** The contexts for compilation units that are parsed but not yet entered */
   private[this] var remaining: List[Context] = Nil
@@ -30,7 +30,7 @@ class FrontEnd extends Phase {
   def stillToBeEntered(name: String): Boolean =
     remaining.exists(_.compilationUnit.toString.endsWith(name + ".scala"))
 
-  def monitor(doing: String)(body: => Unit)(implicit ctx: Context) =
+  def monitor(doing: String)(body: => Unit)(implicit ctx: Context): Unit =
     try body
     catch {
       case NonFatal(ex) =>
@@ -38,7 +38,7 @@ class FrontEnd extends Phase {
         throw ex
     }
 
-  def parse(implicit ctx: Context) = monitor("parsing") {
+  def parse(implicit ctx: Context): Unit = monitor("parsing") {
     val unit = ctx.compilationUnit
     unit.untpdTree =
       if (unit.isJava) new JavaParser(unit.source).parse()
@@ -49,13 +49,13 @@ class FrontEnd extends Phase {
       unit.untpdTree.checkPos(nonOverlapping = !unit.isJava && !ctx.reporter.hasErrors)
   }
 
-  def enterSyms(implicit ctx: Context) = monitor("indexing") {
+  def enterSyms(implicit ctx: Context): Unit = monitor("indexing") {
     val unit = ctx.compilationUnit
     ctx.typer.index(unit.untpdTree)
     typr.println("entered: " + unit.source)
   }
 
-  def typeCheck(implicit ctx: Context) = monitor("typechecking") {
+  def typeCheck(implicit ctx: Context): Unit = monitor("typechecking") {
     val unit = ctx.compilationUnit
     unit.tpdTree = ctx.typer.typedExpr(unit.untpdTree)
     typr.println("typed: " + unit.source)
@@ -70,7 +70,7 @@ class FrontEnd extends Phase {
     case _ => NoSymbol
   }
 
-  protected def discardAfterTyper(unit: CompilationUnit)(implicit ctx: Context) =
+  protected def discardAfterTyper(unit: CompilationUnit)(implicit ctx: Context): Boolean =
     unit.isJava || firstTopLevelDef(unit.tpdTree :: Nil).isPrimitiveValueClass
 
   override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
@@ -98,5 +98,5 @@ class FrontEnd extends Phase {
 }
 
 object FrontEnd {
-  val name = "frontend"
+  val name: String = "frontend"
 }
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 780f80aa50d5..ebca515c08c0 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -3,7 +3,7 @@ package dotc
 package typer
 
 import core._
-import ast.{Trees, untpd, tpd, TreeInfo}
+import ast.{Trees, untpd, tpd}
 import util.Positions._
 import util.Stats.{track, record, monitored}
 import printing.{Showable, Printer}
@@ -13,27 +13,23 @@ import Types._
 import Flags._
 import TypeErasure.{erasure, hasStableErasure}
 import Mode.ImplicitsEnabled
-import Denotations._
 import NameOps._
 import NameKinds.LazyImplicitName
-import SymDenotations._
 import Symbols._
 import Types._
 import Decorators._
 import Names._
 import StdNames._
 import Constants._
-import Applications._
 import ProtoTypes._
 import ErrorReporting._
-import Annotations.Annotation
-import reporting.diagnostic.{Message, MessageContainer}
+import reporting.diagnostic.Message
 import Inferencing.fullyDefinedType
 import Trees._
 import Hashable._
 import util.Property
 import config.Config
-import config.Printers.{implicits, implicitsDetailed, typr}
+import config.Printers.{implicits, implicitsDetailed}
 import collection.mutable
 import reporting.trace
 
@@ -46,7 +42,7 @@ object Implicits {
   /** A reference to an implicit value to be made visible on the next nested call to
    *  inferImplicitArg with a by-name expected type.
    */
-  val DelayedImplicit = new Property.Key[TermRef]
+  val DelayedImplicit: Property.Key[TermRef] = new Property.Key
 
   /** An implicit definition `implicitRef` that is visible under a different name, `alias`.
    *  Gets generated if an implicit ref is imported via a renaming import.
@@ -206,7 +202,7 @@ object Implicits {
         }
       }
 
-    override def toString =
+    override def toString: String =
       i"OfTypeImplicits($tp), companions = ${companionRefs.toList}%, %; refs = $refs%, %."
   }
 
@@ -273,7 +269,7 @@ object Implicits {
       }
     }
 
-    override def toString = {
+    override def toString: String = {
       val own = i"(implicits: $refs%, %)"
       if (isOuterMost) own else own + "\n " + outerImplicits
     }
@@ -295,11 +291,11 @@ object Implicits {
   sealed abstract class SearchResult extends Showable {
     def tree: Tree
     def toText(printer: Printer): Text = printer.toText(this)
-    def recoverWith(other: SearchFailure => SearchResult) = this match {
+    def recoverWith(other: SearchFailure => SearchResult): SearchResult = this match {
       case _: SearchSuccess => this
       case fail: SearchFailure => other(fail)
     }
-    def isSuccess = isInstanceOf[SearchSuccess]
+    def isSuccess: Boolean = isInstanceOf[SearchSuccess]
   }
 
   /** A successful search
@@ -312,8 +308,8 @@ object Implicits {
 
   /** A failed search */
   case class SearchFailure(tree: Tree) extends SearchResult {
-    final def isAmbiguous = tree.tpe.isInstanceOf[AmbiguousImplicits]
-    final def reason = tree.tpe.asInstanceOf[SearchFailureType]
+    final def isAmbiguous: Boolean = tree.tpe.isInstanceOf[AmbiguousImplicits]
+    final def reason: SearchFailureType = tree.tpe.asInstanceOf[SearchFailureType]
   }
 
   object SearchFailure {
@@ -329,7 +325,7 @@ object Implicits {
     def expectedType: Type
     protected def argument: Tree
 
-    final protected def qualify(implicit ctx: Context) =
+    final protected def qualify(implicit ctx: Context): String =
       if (expectedType.exists)
         if (argument.isEmpty) em"match type $expectedType"
         else em"convert from ${argument.tpe} to $expectedType"
@@ -362,7 +358,7 @@ object Implicits {
   class AmbiguousImplicits(val alt1: SearchSuccess, val alt2: SearchSuccess, val expectedType: Type, val argument: Tree) extends SearchFailureType {
     def explanation(implicit ctx: Context): String =
       em"both ${err.refStr(alt1.ref)} and ${err.refStr(alt2.ref)} $qualify"
-    override def whyNoConversion(implicit ctx: Context) =
+    override def whyNoConversion(implicit ctx: Context): String =
       "\nNote that implicit conversions cannot be applied because they are ambiguous;" +
       "\n" + explanation
   }
@@ -379,7 +375,7 @@ object Implicits {
                          val expectedType: Type,
                          val argument: Tree) extends SearchFailureType {
     /** same as err.refStr but always prints owner even if it is a term */
-    def show(ref: Type)(implicit ctx: Context) = ref match {
+    def show(ref: Type)(implicit ctx: Context): String = ref match {
       case ref: NamedType if ref.symbol.maybeOwner.isTerm =>
         i"${ref.symbol} in ${ref.symbol.owner}"
       case _ => err.refStr(ref)
@@ -519,7 +515,7 @@ trait ImplicitRunInfo { self: Run =>
     iscope(rootTp)
   }
 
-  protected def reset() = {
+  protected def reset(): Unit = {
     implicitScopeCache.clear()
   }
 }
@@ -909,18 +905,18 @@ trait Implicits { self: Typer =>
     private val cmpCandidates = (c1: Candidate, c2: Candidate) => compare(c1.ref, c2.ref, c1.level, c2.level)(cmpContext)
 
     /** The expected type for the searched implicit */
-    lazy val fullProto = implicitProto(pt, identity)
+    lazy val fullProto: Type = implicitProto(pt, identity)
 
-    lazy val funProto = fullProto match {
+    lazy val funProto: Type = fullProto match {
       case proto: ViewProto =>
         FunProto(untpd.TypedSplice(dummyTreeOfType(proto.argType)) :: Nil, proto.resultType)(self)
       case proto => proto
     }
 
     /** The expected type where parameters and uninstantiated typevars are replaced by wildcard types */
-    val wildProto = implicitProto(pt, wildApprox(_))
+    val wildProto: Type = implicitProto(pt, wildApprox(_))
 
-    val isNot = wildProto.classSymbol == defn.NotClass
+    val isNot: Boolean = wildProto.classSymbol == defn.NotClass
 
       //println(i"search implicits $pt / ${eligible.map(_.ref)}")
 
@@ -1244,7 +1240,7 @@ class SearchHistory(val searchDepth: Int, val seen: Map[ClassSymbol, Int]) {
     }
   }
 
-  override def toString = s"SearchHistory(depth = $searchDepth, seen = $seen)"
+  override def toString: String = s"SearchHistory(depth = $searchDepth, seen = $seen)"
 }
 
 /** A set of term references where equality is =:= */
diff --git a/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala b/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala
index eecf905169eb..5506b78aea22 100644
--- a/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ImportInfo.scala
@@ -7,13 +7,13 @@ import ast.Trees._
 import core._
 import printing.{Printer, Showable}
 import util.SimpleIdentityMap
-import Symbols._, Names._, Denotations._, Types._, Contexts._, StdNames._, Flags._
-import Decorators.StringInterpolators
+import Symbols._, Names._, Types._, Contexts._, StdNames._, Flags._
 import Implicits.RenamedImplicitRef
+import printing.Texts.Text
 
 object ImportInfo {
   /** The import info for a root import from given symbol `sym` */
-  def rootImport(refFn: () => TermRef)(implicit ctx: Context) = {
+  def rootImport(refFn: () => TermRef)(implicit ctx: Context): ImportInfo = {
     val selectors = untpd.Ident(nme.WILDCARD) :: Nil
     def expr(implicit ctx: Context) = tpd.Ident(refFn())
     def imp(implicit ctx: Context) = tpd.Import(expr, selectors)
@@ -34,7 +34,7 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
 
   // Dotty deviation: we cannot use a lazy val here for the same reason
   // that we cannot use one for `DottyPredefModuleRef`.
-  def sym(implicit ctx: Context) = {
+  def sym(implicit ctx: Context): Symbol = {
     if (mySym == null) {
       mySym = symf(ctx)
       assert(mySym != null)
@@ -59,7 +59,7 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
   def originals: Set[TermName] = { ensureInitialized(); myOriginals }
 
   /** Does the import clause end with wildcard? */
-  def isWildcardImport = { ensureInitialized(); myWildcardImport }
+  def isWildcardImport: Boolean = { ensureInitialized(); myWildcardImport }
 
   private[this] var myExcluded: Set[TermName] = null
   private[this] var myMapped: SimpleIdentityMap[TermName, TermName] = null
@@ -160,5 +160,5 @@ class ImportInfo(symf: Context => Symbol, val selectors: List[untpd.Tree],
   private[this] var lastOwner: Symbol = null
   private[this] var lastResults: SimpleIdentityMap[TermName, java.lang.Boolean] = SimpleIdentityMap.Empty
 
-  def toText(printer: Printer) = printer.toText(this)
+  def toText(printer: Printer): Text = printer.toText(this)
 }
diff --git a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
index 07036a81635a..eae27f16df0c 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inferencing.scala
@@ -4,23 +4,17 @@ package typer
 
 import core._
 import ast._
-import Contexts._, Types._, Flags._, Denotations._, Names._, StdNames._, NameOps._, Symbols._
+import Contexts._, Types._, Flags._, Symbols._
 import Trees._
-import Constants._
-import Scopes._
 import ProtoTypes._
 import NameKinds.UniqueName
-import annotation.unchecked
 import util.Positions._
 import util.{Stats, SimpleIdentityMap}
-import util.common._
 import Decorators._
-import Uniques._
-import config.Printers.{typr, constr}
+import config.Printers.typr
 import annotation.tailrec
 import reporting._
 import collection.mutable
-import config.Config
 
 import scala.annotation.internal.sharable
 
@@ -44,7 +38,7 @@ object Inferencing {
   /** The fully defined type, where all type variables are forced.
    *  Throws an error if type contains wildcards.
    */
-  def fullyDefinedType(tp: Type, what: String, pos: Position)(implicit ctx: Context) =
+  def fullyDefinedType(tp: Type, what: String, pos: Position)(implicit ctx: Context): Type =
     if (isFullyDefined(tp, ForceDegree.all)) tp
     else throw new Error(i"internal error: type of $what $tp is not fully defined, pos = $pos") // !!! DEBUG
 
@@ -467,8 +461,8 @@ trait Inferencing { this: Typer =>
 /** An enumeration controlling the degree of forcing in "is-dully-defined" checks. */
 @sharable object ForceDegree {
   class Value(val appliesTo: TypeVar => Boolean, val minimizeAll: Boolean, val allowBottom: Boolean = true)
-  val none = new Value(_ => false, minimizeAll = false)
-  val all = new Value(_ => true, minimizeAll = false)
-  val noBottom = new Value(_ => true, minimizeAll = false, allowBottom = false)
+  val none: Value = new Value(_ => false, minimizeAll = false)
+  val all: Value = new Value(_ => true, minimizeAll = false)
+  val noBottom: Value = new Value(_ => true, minimizeAll = false, allowBottom = false)
 }
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Inliner.scala b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
index 51ac332351d0..140428122b5c 100644
--- a/compiler/src/dotty/tools/dotc/typer/Inliner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Inliner.scala
@@ -2,7 +2,6 @@ package dotty.tools
 package dotc
 package typer
 
-import dotty.tools.dotc.ast.Trees.NamedArg
 import dotty.tools.dotc.ast.{Trees, untpd, tpd, TreeTypeMap}
 import Trees._
 import core._
@@ -13,28 +12,20 @@ import Decorators._
 import Constants._
 import StdNames._
 import Contexts.Context
-import Names.{Name, TermName, EmptyTermName}
-import NameOps._
-import NameKinds.{ClassifiedNameKind, InlineAccessorName, UniqueInlineName, InlineScrutineeName, InlineBinderName}
+import Names.Name
 import ProtoTypes.selectionProto
 import SymDenotations.SymDenotation
-import Annotations._
-import transform.{ExplicitOuter, AccessProxies}
 import Inferencing.fullyDefinedType
 import config.Printers.inlining
 import ErrorReporting.errorTree
 import collection.mutable
-import transform.TypeUtils._
-import transform.SymUtils._
 import reporting.trace
 import util.Positions.Position
-import util.Property
-import ast.TreeInfo
 
 object Inliner {
   import tpd._
 
-  val typedInline = true
+  val typedInline: Boolean = true
 
   /** `sym` is an inline method with a known body to inline (note: definitions coming
    *  from Scala2x class files might be `@forceInline`, but still lack that body).
@@ -124,7 +115,7 @@ object Inliner {
   }
 
   /** Replace `Inlined` node by a block that contains its bindings and expansion */
-  def dropInlined(inlined: tpd.Inlined)(implicit ctx: Context): Tree = {
+  def dropInlined(inlined: Inlined)(implicit ctx: Context): Tree = {
     if (enclosingInlineds.nonEmpty) inlined // Remove in the outer most inlined call
     else {
       val inlinedAtPos = inlined.call.pos
@@ -149,7 +140,7 @@ object Inliner {
               }
           }
         }
-        def transformInline(tree: tpd.Inlined)(implicit ctx: Context): Tree = {
+        def transformInline(tree: Inlined)(implicit ctx: Context): Tree = {
           tpd.seq(transformSub(tree.bindings), transform(tree.expansion)(inlineContext(tree.call)))
         }
       }
@@ -166,7 +157,6 @@ object Inliner {
  */
 class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
   import tpd._
-  import Inliner._
 
   private val (methPart, callTypeArgs, callValueArgss) = decomposeCall(call)
   private val inlinedMethod = methPart.symbol
@@ -334,7 +324,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
    *  from its `originalOwner`, and, if it comes from outside the inlined method
    *  itself, it has to be marked as an inlined argument.
    */
-  def integrate(tree: Tree, originalOwner: Symbol)(implicit ctx: Context) = {
+  def integrate(tree: Tree, originalOwner: Symbol)(implicit ctx: Context): Tree = {
     val result = tree.changeOwner(originalOwner, ctx.owner)
     if (!originalOwner.isContainedIn(inlinedMethod)) Inlined(EmptyTree, Nil, result)
     else result
@@ -494,13 +484,13 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     }
 
     object ConstantValue {
-      def unapply(tree: Tree)(implicit ctx: Context) = tree.tpe.widenTermRefExpr match {
+      def unapply(tree: Tree)(implicit ctx: Context): Option[Any] = tree.tpe.widenTermRefExpr match {
         case ConstantType(Constant(x)) => Some(x)
         case _ => None
       }
     }
 
-    def tryInline(tree: tpd.Tree)(implicit ctx: Context) = tree match {
+    def tryInline(tree: Tree)(implicit ctx: Context): Tree = tree match {
       case InlineableArg(rhs) =>
         inlining.println(i"inline arg $tree -> $rhs")
         rhs
@@ -519,7 +509,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
       *  where `def` is used for call-by-name parameters. However, we shortcut any NoPrefix
       *  refs among the ei's directly without creating an intermediate binding.
       */
-    def betaReduce(tree: Tree)(implicit ctx: Context) = tree match {
+    def betaReduce(tree: Tree)(implicit ctx: Context): Tree = tree match {
       case Apply(Select(cl @ closureDef(ddef), nme.apply), args) if defn.isFunctionType(cl.tpe) =>
         ddef.tpe.widen match {
           case mt: MethodType if ddef.vparamss.head.length == args.length =>
@@ -568,7 +558,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
     }
 
 
-    override def typedIdent(tree: untpd.Ident, pt: Type)(implicit ctx: Context) =
+    override def typedIdent(tree: untpd.Ident, pt: Type)(implicit ctx: Context): Tree =
       tryInline(tree.asInstanceOf[tpd.Tree]) `orElse` super.typedIdent(tree, pt)
 
     override def typedSelect(tree: untpd.Select, pt: Type)(implicit ctx: Context): Tree = {
@@ -579,7 +569,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
       res
     }
 
-    override def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context) =
+    override def typedIf(tree: untpd.If, pt: Type)(implicit ctx: Context): Tree =
       typed(tree.cond, defn.BooleanType) match {
         case cond1 @ ConstantValue(b: Boolean) =>
           val selected0 = if (b) tree.thenp else tree.elsep
@@ -591,7 +581,7 @@ class Inliner(call: tpd.Tree, rhsToInline: tpd.Tree)(implicit ctx: Context) {
           super.typedIf(if1, pt)
       }
 
-    override def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context) =
+    override def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree =
       constToLiteral(betaReduce(super.typedApply(tree, pt)))
 
     override def newLikeThis: Typer = new InlineTyper
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index 762cf2e6da16..67cfbef85ae5 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -4,30 +4,26 @@ package typer
 
 import core._
 import ast._
-import Trees._, Constants._, StdNames._, Scopes._, Denotations._, Comments._
+import Trees._, StdNames._, Scopes._, Denotations._, Comments._
 import Contexts._, Symbols._, Types._, SymDenotations._, Names._, NameOps._, Flags._, Decorators._
 import NameKinds.DefaultGetterName
 import ast.desugar, ast.desugar._
 import ProtoTypes._
 import util.Positions._
-import util.{Property, SourcePosition, DotClass}
+import util.Property
 import collection.mutable
-import annotation.tailrec
-import ErrorReporting._
 import tpd.ListOfTreeDecorator
 import config.Config
-import config.Printers.{typr, noPrinter}
+import config.Printers.typr
 import Annotations._
 import Inferencing._
 import transform.ValueClasses._
-import TypeApplications._
-import language.implicitConversions
 import reporting.diagnostic.messages._
 
 trait NamerContextOps { this: Context =>
   import NamerContextOps._
 
-  def typer = ctx.typeAssigner match {
+  def typer: Typer = ctx.typeAssigner match {
     case typer: Typer => typer
     case _ => new Typer
   }
@@ -68,7 +64,7 @@ trait NamerContextOps { this: Context =>
     else scope
 
   /** The symbol (stored in some typer's symTree) of an enclosing context definition */
-  def symOfContextTree(tree: untpd.Tree) = {
+  def symOfContextTree(tree: untpd.Tree): Symbol = {
     def go(ctx: Context): Symbol = {
       ctx.typeAssigner match {
         case typer: Typer =>
@@ -86,7 +82,7 @@ trait NamerContextOps { this: Context =>
   }
 
   /** Context where `sym` is defined, assuming we are in a nested context. */
-  def defContext(sym: Symbol) =
+  def defContext(sym: Symbol): Context =
     outersIterator
       .dropWhile(_.owner != sym)
       .dropWhile(_.owner == sym)
@@ -118,12 +114,12 @@ trait NamerContextOps { this: Context =>
   /** The given type, unless `sym` is a constructor, in which case the
    *  type of the constructed instance is returned
    */
-  def effectiveResultType(sym: Symbol, typeParams: List[Symbol], given: Type) =
+  def effectiveResultType(sym: Symbol, typeParams: List[Symbol], given: Type): Type =
     if (sym.name == nme.CONSTRUCTOR) sym.owner.typeRef.appliedTo(typeParams.map(_.typeRef))
     else given
 
   /** if isConstructor, make sure it has one non-implicit parameter list */
-  def normalizeIfConstructor(termParamss: List[List[Symbol]], isConstructor: Boolean) =
+  def normalizeIfConstructor(termParamss: List[List[Symbol]], isConstructor: Boolean): List[List[Symbol]] =
     if (isConstructor &&
       (termParamss.isEmpty || termParamss.head.nonEmpty && (termParamss.head.head is Implicit)))
       Nil :: termParamss
@@ -141,7 +137,7 @@ trait NamerContextOps { this: Context =>
         if (isJava)
           for (param <- params)
             if (param.info.isDirectRef(defn.ObjectClass)) param.info = defn.AnyType
-        make.fromSymbols(params.asInstanceOf[List[TermSymbol]], resultType)
+        make.fromSymbols(params.asInstanceOf[List[Symbol]], resultType)
       }
     if (typeParams.nonEmpty) PolyType.fromParams(typeParams.asInstanceOf[List[TypeSymbol]], monotpe)
     else if (valueParamss.isEmpty) ExprType(monotpe)
@@ -151,7 +147,7 @@ trait NamerContextOps { this: Context =>
   /** Add moduleClass or sourceModule functionality to completer
    *  for a module or module class
    */
-  def adjustModuleCompleter(completer: LazyType, name: Name) = {
+  def adjustModuleCompleter(completer: LazyType, name: Name): LazyType = {
     val scope = this.effectiveScope
     if (name.isTermName)
       completer withModuleClass (implicit ctx => findModuleBuddy(name.moduleClassName, scope))
@@ -193,9 +189,9 @@ class Namer { typer: Typer =>
 
   import untpd._
 
-  val TypedAhead = new Property.Key[tpd.Tree]
-  val ExpandedTree = new Property.Key[Tree]
-  val SymOfTree = new Property.Key[Symbol]
+  val TypedAhead: Property.Key[tpd.Tree] = new Property.Key
+  val ExpandedTree: Property.Key[untpd.Tree] = new Property.Key
+  val SymOfTree: Property.Key[Symbol] = new Property.Key
 
   /** A partial map from unexpanded member and pattern defs and to their expansions.
    *  Populated during enterSyms, emptied during typer.
@@ -223,14 +219,14 @@ class Namer { typer: Typer =>
    *  one, so that trees that are shared between different DefDefs can be independently
    *  used as indices. It also contains a scope that contains nested parameters.
    */
-  lazy val nestedTyper = new mutable.AnyRefMap[Symbol, Typer]
+  lazy val nestedTyper: mutable.AnyRefMap[Symbol, Typer] = new mutable.AnyRefMap
 
   /** The scope of the typer.
    *  For nested typers this is a place parameters are entered during completion
    *  and where they survive until typechecking. A context with this typer also
    *  has this scope.
    */
-  val scope = newScope
+  val scope: MutableScope = newScope
 
   /** We are entering symbols coming from a SourceLoader */
   private[this] var lateCompile = false
@@ -376,7 +372,7 @@ class Namer { typer: Typer =>
    /** If `sym` exists, enter it in effective scope. Check that
     *  package members are not entered twice in the same run.
     */
-  def enterSymbol(sym: Symbol)(implicit ctx: Context) = {
+  def enterSymbol(sym: Symbol)(implicit ctx: Context): Symbol = {
     if (sym.exists) {
       typr.println(s"entered: $sym in ${ctx.owner}")
       ctx.enter(sym)
@@ -487,7 +483,7 @@ class Namer { typer: Typer =>
     *  - The field is static
     *  - The field is stable
     */
-  def isEnumConstant(vd: ValDef)(implicit ctx: Context) = {
+  def isEnumConstant(vd: ValDef)(implicit ctx: Context): Boolean = {
     // val ownerHasEnumFlag =
     // Necessary to check because scalac puts Java's static members into the companion object
     // while Scala's enum constants live directly in the class.
@@ -507,7 +503,7 @@ class Namer { typer: Typer =>
   }
 
 
-  def setDocstring(sym: Symbol, tree: Tree)(implicit ctx: Context) = tree match {
+  def setDocstring(sym: Symbol, tree: Tree)(implicit ctx: Context): Unit = tree match {
     case t: MemberDef if t.rawComment.isDefined =>
       ctx.docCtx.foreach(_.addDocstring(sym, t.rawComment))
     case _ => ()
@@ -691,13 +687,13 @@ class Namer { typer: Typer =>
    *  This will cause any old top-level symbol with the same fully qualified
    *  name as a newly created symbol to be replaced.
    */
-  def lateEnter(tree: Tree)(implicit ctx: Context) = {
+  def lateEnter(tree: Tree)(implicit ctx: Context): Context = {
     val saved = lateCompile
     lateCompile = true
     try index(tree :: Nil) finally lateCompile = saved
   }
 
-  def missingType(sym: Symbol, modifier: String)(implicit ctx: Context) = {
+  def missingType(sym: Symbol, modifier: String)(implicit ctx: Context): Unit = {
     ctx.error(s"${modifier}type of implicit definition needs to be given explicitly", sym.pos)
     sym.resetFlag(Implicit)
   }
@@ -705,10 +701,10 @@ class Namer { typer: Typer =>
   /** The completer of a symbol defined by a member def or import (except ClassSymbols) */
   class Completer(val original: Tree)(implicit ctx: Context) extends LazyType with SymbolLoaders.SecondCompleter {
 
-    protected def localContext(owner: Symbol) = ctx.fresh.setOwner(owner).setTree(original)
+    protected def localContext(owner: Symbol): FreshContext = ctx.fresh.setOwner(owner).setTree(original)
 
     /** The context with which this completer was created */
-    def creationContext = ctx
+    def creationContext: Context = ctx
     ctx.typerState.markShared()
 
     protected def typeSig(sym: Symbol): Type = original match {
@@ -730,7 +726,7 @@ class Namer { typer: Typer =>
         }
     }
 
-    final override def complete(denot: SymDenotation)(implicit ctx: Context) = {
+    final override def complete(denot: SymDenotation)(implicit ctx: Context): Unit = {
       if (Config.showCompletions && ctx.typerState != this.ctx.typerState) {
         def levels(c: Context): Int =
           if (c.typerState eq this.ctx.typerState) 0
@@ -844,13 +840,13 @@ class Namer { typer: Typer =>
 
     val TypeDef(name, impl @ Template(constr, parents, self, _)) = original
 
-    val (params, rest) = impl.body span {
+    private val ((params: List[Tree]), (rest: List[Tree])) = impl.body span {
       case td: TypeDef => td.mods is Param
       case vd: ValDef => vd.mods is ParamAccessor
       case _ => false
     }
 
-    def init() = index(params)
+    def init(): Context = index(params)
 
     /** The type signature of a ClassDef with given symbol */
     override def completeInCreationContext(denot: SymDenotation): Unit = {
@@ -983,7 +979,7 @@ class Namer { typer: Typer =>
   }
 
   /** Enter and typecheck parameter list */
-  def completeParams(params: List[MemberDef])(implicit ctx: Context) = {
+  def completeParams(params: List[MemberDef])(implicit ctx: Context): Unit = {
     index(params)
     for (param <- params) typedAheadExpr(param)
   }
@@ -1155,7 +1151,7 @@ class Namer { typer: Typer =>
   }
 
   /** The type signature of a DefDef with given symbol */
-  def defDefSig(ddef: DefDef, sym: Symbol)(implicit ctx: Context) = {
+  def defDefSig(ddef: DefDef, sym: Symbol)(implicit ctx: Context): Type = {
     // Beware: ddef.name need not match sym.name if sym was freshened!
     val DefDef(_, tparams, vparamss, _, _) = ddef
     val isConstructor = sym.name == nme.CONSTRUCTOR
diff --git a/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala b/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala
index 847466a7552b..ef8e4b42c06d 100644
--- a/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala
+++ b/compiler/src/dotty/tools/dotc/typer/PrepareInlineable.scala
@@ -2,33 +2,22 @@ package dotty.tools
 package dotc
 package typer
 
-import dotty.tools.dotc.ast.Trees.NamedArg
-import dotty.tools.dotc.ast.{Trees, untpd, tpd, TreeTypeMap}
+import dotty.tools.dotc.ast.{Trees, untpd, tpd}
 import Trees._
 import core._
 import Flags._
 import Symbols._
 import Types._
 import Decorators._
-import Constants._
+import NameKinds._
 import StdNames.nme
 import Contexts.Context
-import Names.{Name, TermName, EmptyTermName}
-import NameOps._
-import NameKinds.{ClassifiedNameKind, InlineAccessorName, UniqueInlineName}
-import ProtoTypes.selectionProto
-import SymDenotations.SymDenotation
+import Names.Name
+import NameKinds.{InlineAccessorName, UniqueInlineName}
 import Annotations._
-import transform.{ExplicitOuter, AccessProxies}
-import Inferencing.fullyDefinedType
+import transform.AccessProxies
 import config.Printers.inlining
-import ErrorReporting.errorTree
-import collection.mutable
-import transform.TypeUtils._
-import reporting.trace
-import util.Positions.Position
 import util.Property
-import ast.TreeInfo
 
 object PrepareInlineable {
   import tpd._
@@ -49,7 +38,7 @@ object PrepareInlineable {
      *  that the inline accessor takes its receiver as first parameter. Such accessors
      *  are created by MakeInlineablePassing.
      */
-    override def passReceiverAsArg(name: Name)(implicit ctx: Context) = name match {
+    override def passReceiverAsArg(name: Name)(implicit ctx: Context): Boolean = name match {
       case InlineAccessorName(UniqueInlineName(_, _)) => true
       case _ => false
     }
@@ -57,7 +46,7 @@ object PrepareInlineable {
     /** A tree map which inserts accessors for non-public term members accessed from inlined code.
      */
     abstract class MakeInlineableMap(val inlineSym: Symbol) extends TreeMap with Insert {
-      def accessorNameKind = InlineAccessorName
+      def accessorNameKind: PrefixNameKind = InlineAccessorName
 
       /** A definition needs an accessor if it is private, protected, or qualified private
        *  and it is not part of the tree that gets inlined. The latter test is implemented
@@ -66,7 +55,7 @@ object PrepareInlineable {
        *  Constant vals don't need accessors since they are inlined in FirstTransform.
        *  Inline methods don't need accessors since they are inlined in Typer.
        */
-      def needsAccessor(sym: Symbol)(implicit ctx: Context) =
+      def needsAccessor(sym: Symbol)(implicit ctx: Context): Boolean =
         sym.isTerm &&
         (sym.is(AccessFlags) || sym.privateWithin.exists) &&
         !sym.isContainedIn(inlineSym) &&
@@ -75,7 +64,7 @@ object PrepareInlineable {
 
       def preTransform(tree: Tree)(implicit ctx: Context): Tree
 
-      def postTransform(tree: Tree)(implicit ctx: Context) = tree match {
+      def postTransform(tree: Tree)(implicit ctx: Context): Tree = tree match {
         case Assign(lhs, rhs) if lhs.symbol.name.is(InlineAccessorName) =>
           cpy.Apply(tree)(useSetter(lhs), rhs :: Nil)
         case _ =>
@@ -203,7 +192,7 @@ object PrepareInlineable {
      *  @return If there are accessors generated, a thicket consisting of the rewritten `tree`
      *          and all accessors, otherwise the original tree.
      */
-    def makeInlineable(tree: Tree)(implicit ctx: Context) = {
+    def makeInlineable(tree: Tree)(implicit ctx: Context): Tree = {
       val inlineSym = ctx.owner
       if (inlineSym.owner.isTerm)
         // Inlineable methods in local scopes can only be called in the scope they are defined,
@@ -215,10 +204,10 @@ object PrepareInlineable {
     }
   }
 
-  def isLocalOrParam(sym: Symbol, inlineMethod: Symbol)(implicit ctx: Context) =
+  def isLocalOrParam(sym: Symbol, inlineMethod: Symbol)(implicit ctx: Context): Boolean =
     sym.isContainedIn(inlineMethod) && sym != inlineMethod
 
-  def isLocal(sym: Symbol, inlineMethod: Symbol)(implicit ctx: Context) =
+  def isLocal(sym: Symbol, inlineMethod: Symbol)(implicit ctx: Context): Boolean =
     isLocalOrParam(sym, inlineMethod) && !(sym.is(Param) && sym.owner == inlineMethod)
 
   /** Register inline info for given inlineable method `sym`.
@@ -252,7 +241,7 @@ object PrepareInlineable {
     }
   }
 
-  def checkInlineMethod(inlined: Symbol, body: Tree)(implicit ctx: Context) = {
+  def checkInlineMethod(inlined: Symbol, body: Tree)(implicit ctx: Context): Unit = {
     if (ctx.outer.inInlineMethod)
       ctx.error(ex"implementation restriction: nested inline methods are not supported", inlined.pos)
     if (inlined.name == nme.unapply && tupleArgs(body).isEmpty)
@@ -260,4 +249,4 @@ object PrepareInlineable {
         em"inline unapply method can be rewritten only if its right hand side is a tuple (e1, ..., eN)",
         body.pos)
   }
-}
\ No newline at end of file
+}
diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index 52882c91d63a..a75f344f3da6 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -4,20 +4,14 @@ package typer
 
 import core._
 import ast._
-import Contexts._, Types._, Flags._, Denotations._, Names._, StdNames._, NameOps._, Symbols._
+import Contexts._, Types._, Denotations._, Names._, StdNames._, NameOps._, Symbols._
 import NameKinds.DepParamName
 import Trees._
 import Constants._
-import Scopes._
-import annotation.unchecked
-import util.Positions._
 import util.{Stats, SimpleIdentityMap}
-import util.common._
 import Decorators._
 import Uniques._
-import ErrorReporting.errorType
 import config.Printers.typr
-import collection.mutable
 
 import scala.annotation.internal.sharable
 
@@ -41,7 +35,7 @@ object ProtoTypes {
       (tp.widenExpr relaxed_<:< pt.widenExpr) || viewExists(tp, pt)
 
     /** Test compatibility after normalization in a fresh typerstate. */
-    def normalizedCompatible(tp: Type, pt: Type)(implicit ctx: Context) =
+    def normalizedCompatible(tp: Type, pt: Type)(implicit ctx: Context): Boolean =
       ctx.test { implicit ctx =>
         val normTp = normalize(tp, pt)
         isCompatible(normTp, pt) || pt.isRef(defn.UnitClass) && normTp.isParameterless
@@ -94,10 +88,10 @@ object ProtoTypes {
 
   /** A trait for prototypes that match all types */
   trait MatchAlways extends ProtoType {
-    def isMatchedBy(tp1: Type)(implicit ctx: Context) = true
+    def isMatchedBy(tp1: Type)(implicit ctx: Context): Boolean = true
     def map(tm: TypeMap)(implicit ctx: Context): ProtoType = this
     def fold[T](x: T, ta: TypeAccumulator[T])(implicit ctx: Context): T = x
-    override def toString = getClass.toString
+    override def toString: String = getClass.toString
   }
 
   /** A class marking ignored prototypes that can be revealed by `deepenProto` */
@@ -135,7 +129,7 @@ object ProtoTypes {
       case _ => false
     }
 
-    override def isMatchedBy(tp1: Type)(implicit ctx: Context) = {
+    override def isMatchedBy(tp1: Type)(implicit ctx: Context): Boolean = {
       name == nme.WILDCARD || hasUnknownMembers(tp1) ||
       {
         val mbr = if (privateOK) tp1.member(name) else tp1.nonPrivateMember(name)
@@ -151,9 +145,9 @@ object ProtoTypes {
       }
     }
 
-    def underlying(implicit ctx: Context) = WildcardType
+    def underlying(implicit ctx: Context): Type = WildcardType
 
-    def derivedSelectionProto(name: Name, memberProto: Type, compat: Compatibility)(implicit ctx: Context) =
+    def derivedSelectionProto(name: Name, memberProto: Type, compat: Compatibility)(implicit ctx: Context): SelectionProto =
       if ((name eq this.name) && (memberProto eq this.memberProto) && (compat eq this.compat)) this
       else SelectionProto(name, memberProto, compat, privateOK)
 
@@ -164,12 +158,12 @@ object ProtoTypes {
         false
     }
 
-    def map(tm: TypeMap)(implicit ctx: Context) = derivedSelectionProto(name, tm(memberProto), compat)
-    def fold[T](x: T, ta: TypeAccumulator[T])(implicit ctx: Context) = ta(x, memberProto)
+    def map(tm: TypeMap)(implicit ctx: Context): SelectionProto = derivedSelectionProto(name, tm(memberProto), compat)
+    def fold[T](x: T, ta: TypeAccumulator[T])(implicit ctx: Context): T = ta(x, memberProto)
 
-    override def deepenProto(implicit ctx: Context) = derivedSelectionProto(name, memberProto.deepenProto, compat)
+    override def deepenProto(implicit ctx: Context): SelectionProto = derivedSelectionProto(name, memberProto.deepenProto, compat)
 
-    override def computeHash(bs: Hashable.Binders) = {
+    override def computeHash(bs: Hashable.Binders): Int = {
       val delta = (if (compat eq NoViewsAllowed) 1 else 0) | (if (privateOK) 2 else 0)
       addDelta(doHash(bs, name, memberProto), delta)
     }
@@ -188,7 +182,7 @@ object ProtoTypes {
   /** Create a selection proto-type, but only one level deep;
    *  treat constructors specially
    */
-  def selectionProto(name: Name, tp: Type, typer: Typer)(implicit ctx: Context) =
+  def selectionProto(name: Name, tp: Type, typer: Typer)(implicit ctx: Context): TermType =
     if (name.isConstructorName) WildcardType
     else tp match {
       case tp: UnapplyFunProto => new UnapplySelectionProto(name)
@@ -234,16 +228,16 @@ object ProtoTypes {
    */
   case class FunProto(args: List[untpd.Tree], resType: Type)(typer: Typer, state: FunProtoState = new FunProtoState)(implicit ctx: Context)
   extends UncachedGroundType with ApplyingProto {
-    override def resultType(implicit ctx: Context) = resType
+    override def resultType(implicit ctx: Context): Type = resType
 
-    def isMatchedBy(tp: Type)(implicit ctx: Context) =
+    def isMatchedBy(tp: Type)(implicit ctx: Context): Boolean =
       typer.isApplicable(tp, Nil, unforcedTypedArgs, resultType)
 
-    def derivedFunProto(args: List[untpd.Tree] = this.args, resultType: Type, typer: Typer = this.typer) =
+    def derivedFunProto(args: List[untpd.Tree] = this.args, resultType: Type, typer: Typer = this.typer): FunProto =
       if ((args eq this.args) && (resultType eq this.resultType) && (typer eq this.typer)) this
       else new FunProto(args, resultType)(typer)
 
-    override def notApplied = WildcardType
+    override def notApplied: Type = WildcardType
 
     /** Forget the types of any arguments that have been typed producing a constraint
      *    - that is in a typer state that is not yet committed into the one of the current context `ctx`,
@@ -336,14 +330,14 @@ object ProtoTypes {
      *  a method is `toString`. If in that case the type in the denotation is
      *  parameterless, we compensate by dropping the application.
      */
-    def markAsDropped() = {
+    def markAsDropped(): Unit = {
       assert(args.isEmpty)
       state.toDrop = true
     }
 
     def isDropped: Boolean = state.toDrop
 
-    override def toString = s"FunProto(${args mkString ","} => $resultType)"
+    override def toString: String = s"FunProto(${args mkString ","} => $resultType)"
 
     def map(tm: TypeMap)(implicit ctx: Context): FunProto =
       derivedFunProto(args, tm(resultType), typer)
@@ -351,9 +345,9 @@ object ProtoTypes {
     def fold[T](x: T, ta: TypeAccumulator[T])(implicit ctx: Context): T =
       ta(ta.foldOver(x, typedArgs.tpes), resultType)
 
-    override def deepenProto(implicit ctx: Context) = derivedFunProto(args, resultType.deepenProto, typer)
+    override def deepenProto(implicit ctx: Context): FunProto = derivedFunProto(args, resultType.deepenProto, typer)
 
-    override def withContext(newCtx: Context) =
+    override def withContext(newCtx: Context): ProtoType =
       if (newCtx `eq` ctx) this
       else new FunProto(args, resType)(typer, state)(newCtx)
   }
@@ -363,8 +357,8 @@ object ProtoTypes {
    *  [](args): resultType, where args are known to be typed
    */
   class FunProtoTyped(args: List[tpd.Tree], resultType: Type)(typer: Typer)(implicit ctx: Context) extends FunProto(args, resultType)(typer)(ctx) {
-    override def typedArgs = args
-    override def withContext(ctx: Context) = this
+    override def typedArgs: List[tpd.Tree] = args
+    override def withContext(ctx: Context): FunProtoTyped = this
   }
 
   /** A prototype for implicitly inferred views:
@@ -374,12 +368,12 @@ object ProtoTypes {
   abstract case class ViewProto(argType: Type, resType: Type)
   extends CachedGroundType with ApplyingProto {
 
-    override def resultType(implicit ctx: Context) = resType
+    override def resultType(implicit ctx: Context): Type = resType
 
     def isMatchedBy(tp: Type)(implicit ctx: Context): Boolean =
       ctx.typer.isApplicable(tp, argType :: Nil, resultType)
 
-    def derivedViewProto(argType: Type, resultType: Type)(implicit ctx: Context) =
+    def derivedViewProto(argType: Type, resultType: Type)(implicit ctx: Context): ViewProto =
       if ((argType eq this.argType) && (resultType eq this.resultType)) this
       else ViewProto(argType, resultType)
 
@@ -388,15 +382,15 @@ object ProtoTypes {
     def fold[T](x: T, ta: TypeAccumulator[T])(implicit ctx: Context): T =
       ta(ta(x, argType), resultType)
 
-    override def deepenProto(implicit ctx: Context) = derivedViewProto(argType, resultType.deepenProto)
+    override def deepenProto(implicit ctx: Context): ViewProto = derivedViewProto(argType, resultType.deepenProto)
   }
 
   class CachedViewProto(argType: Type, resultType: Type) extends ViewProto(argType, resultType) {
-    override def computeHash(bs: Hashable.Binders) = doHash(bs, argType, resultType)
+    override def computeHash(bs: Hashable.Binders): Int = doHash(bs, argType, resultType)
   }
 
   object ViewProto {
-    def apply(argType: Type, resultType: Type)(implicit ctx: Context) =
+    def apply(argType: Type, resultType: Type)(implicit ctx: Context): ViewProto =
       unique(new CachedViewProto(argType, resultType))
   }
 
@@ -409,9 +403,9 @@ object ProtoTypes {
    */
   case class PolyProto(targs: List[Type], resType: Type) extends UncachedGroundType with ProtoType {
 
-    override def resultType(implicit ctx: Context) = resType
+    override def resultType(implicit ctx: Context): Type = resType
 
-    override def isMatchedBy(tp: Type)(implicit ctx: Context) = {
+    override def isMatchedBy(tp: Type)(implicit ctx: Context): Boolean = {
       def isInstantiatable(tp: Type) = tp.widen match {
         case tp: PolyType => tp.paramNames.length == targs.length
         case _ => false
@@ -419,11 +413,11 @@ object ProtoTypes {
       isInstantiatable(tp) || tp.member(nme.apply).hasAltWith(d => isInstantiatable(d.info))
     }
 
-    def derivedPolyProto(targs: List[Type], resultType: Type) =
+    def derivedPolyProto(targs: List[Type], resultType: Type): PolyProto =
       if ((targs eq this.targs) && (resType eq this.resType)) this
       else PolyProto(targs, resType)
 
-    override def notApplied = WildcardType
+    override def notApplied: Type = WildcardType
 
     def map(tm: TypeMap)(implicit ctx: Context): PolyProto =
       derivedPolyProto(targs mapConserve tm, tm(resultType))
@@ -431,7 +425,7 @@ object ProtoTypes {
     def fold[T](x: T, ta: TypeAccumulator[T])(implicit ctx: Context): T =
       ta(ta.foldOver(x, targs), resultType)
 
-    override def deepenProto(implicit ctx: Context) = derivedPolyProto(targs, resultType.deepenProto)
+    override def deepenProto(implicit ctx: Context): PolyProto = derivedPolyProto(targs, resultType.deepenProto)
   }
 
   /** A prototype for expressions [] that are known to be functions:
@@ -636,7 +630,7 @@ object ProtoTypes {
   @sharable object AssignProto extends UncachedGroundType with MatchAlways
 
   private[ProtoTypes] class WildApproxMap(val seen: Set[TypeParamRef])(implicit ctx: Context) extends TypeMap {
-    def apply(tp: Type) = wildApprox(tp, this, seen)
+    def apply(tp: Type): Type = wildApprox(tp, this, seen)
   }
 
   /** Dummy tree to be used as an argument of a FunProto or ViewProto type */
diff --git a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
index 7818eff87d34..e3d2f4232dd0 100644
--- a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -9,10 +9,8 @@ import StdNames._
 import Decorators._
 import typer.ProtoTypes._
 import ast.{tpd, untpd}
-import ast.Trees._
 import scala.util.control.NonFatal
 import util.Positions.Position
-import config.Printers.typr
 
 /** A version of Typer that keeps all symbols defined and referenced in a
  *  previously typed tree.
@@ -83,14 +81,14 @@ class ReTyper extends Typer with ReChecking {
     typedApply(tree, selType)
   }
 
-  override def localDummy(cls: ClassSymbol, impl: untpd.Template)(implicit ctx: Context) = impl.symbol
+  override def localDummy(cls: ClassSymbol, impl: untpd.Template)(implicit ctx: Context): Symbol = impl.symbol
 
   override def retrieveSym(tree: untpd.Tree)(implicit ctx: Context): Symbol = tree.symbol
   override def symbolOfTree(tree: untpd.Tree)(implicit ctx: Context): Symbol = tree.symbol
 
-  override def localTyper(sym: Symbol) = this
+  override def localTyper(sym: Symbol): Typer = this
 
-  override def index(trees: List[untpd.Tree])(implicit ctx: Context) = ctx
+  override def index(trees: List[untpd.Tree])(implicit ctx: Context): Context = ctx
 
   override def tryInsertApplyOrImplicit(tree: Tree, pt: ProtoType, locked: TypeVars)(fallBack: => Tree)(implicit ctx: Context): Tree =
     fallBack
@@ -108,7 +106,7 @@ class ReTyper extends Typer with ReChecking {
       super.handleUnexpectedFunType(tree, fun)
   }
 
-  override def typedUnadapted(tree: untpd.Tree, pt: Type, locked: TypeVars)(implicit ctx: Context) =
+  override def typedUnadapted(tree: untpd.Tree, pt: Type, locked: TypeVars)(implicit ctx: Context): Tree =
     try super.typedUnadapted(tree, pt, locked)
     catch {
       case NonFatal(ex) =>
@@ -119,7 +117,7 @@ class ReTyper extends Typer with ReChecking {
 
   override def inlineExpansion(mdef: DefDef)(implicit ctx: Context): Tree = mdef
 
-  override def checkVariance(tree: Tree)(implicit ctx: Context) = ()
+  override def checkVariance(tree: Tree)(implicit ctx: Context): Unit = ()
   override def inferView(from: Tree, to: Type)(implicit ctx: Context): Implicits.SearchResult =
     Implicits.NoMatchingImplicitsFailure
   override def checkCanEqual(ltp: Type, rtp: Type, pos: Position)(implicit ctx: Context): Unit = ()
diff --git a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
index d25617da85c8..e36a6817fb91 100644
--- a/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
+++ b/compiler/src/dotty/tools/dotc/typer/RefChecks.scala
@@ -14,7 +14,6 @@ import ast._
 import Trees._
 import MegaPhase._
 import config.Printers.{checks, noPrinter}
-import util.DotClass
 import scala.util.Failure
 import config.NoScalaVersion
 import Decorators._
@@ -24,7 +23,7 @@ object RefChecks {
   import tpd._
   import reporting.diagnostic.messages._
 
-  val name = "refchecks"
+  val name: String = "refchecks"
 
   private val defaultMethodFilter = new NameFilter {
     def apply(pre: Type, name: Name)(implicit ctx: Context): Boolean = name.is(DefaultGetterName)
@@ -891,7 +890,7 @@ object RefChecks {
         }
   }
 
-  val NoLevelInfo = new OptLevelInfo()
+  val NoLevelInfo: RefChecks.OptLevelInfo = new OptLevelInfo()
 }
 import RefChecks._
 
@@ -934,20 +933,20 @@ class RefChecks extends MiniPhase { thisPhase =>
   override def phaseName: String = RefChecks.name
 
   // Needs to run after ElimRepeated for override checks involving varargs methods
-  override def runsAfter = Set(ElimRepeated.name)
+  override def runsAfter: Set[String] = Set(ElimRepeated.name)
 
   private var LevelInfo: Store.Location[OptLevelInfo] = _
   private def currentLevel(implicit ctx: Context): OptLevelInfo = ctx.store(LevelInfo)
 
-  override def initContext(ctx: FreshContext) =
+  override def initContext(ctx: FreshContext): Unit =
     LevelInfo = ctx.addLocation(NoLevelInfo)
 
-  override def prepareForStats(trees: List[Tree])(implicit ctx: Context) =
+  override def prepareForStats(trees: List[Tree])(implicit ctx: Context): Context =
     if (ctx.owner.isTerm)
       ctx.fresh.updateStore(LevelInfo, new LevelInfo(currentLevel.levelAndIndex, trees))
     else ctx
 
-  override def transformValDef(tree: ValDef)(implicit ctx: Context) = {
+  override def transformValDef(tree: ValDef)(implicit ctx: Context): ValDef = {
     checkDeprecatedOvers(tree)
     val sym = tree.symbol
     if (sym.exists && sym.owner.isTerm) {
@@ -966,12 +965,12 @@ class RefChecks extends MiniPhase { thisPhase =>
     tree
   }
 
-  override def transformDefDef(tree: DefDef)(implicit ctx: Context) = {
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context): DefDef = {
     checkDeprecatedOvers(tree)
     tree
   }
 
-  override def transformTemplate(tree: Template)(implicit ctx: Context) = try {
+  override def transformTemplate(tree: Template)(implicit ctx: Context): Tree = try {
     val cls = ctx.owner
     checkOverloadedRestrictions(cls)
     checkParents(cls)
@@ -985,18 +984,18 @@ class RefChecks extends MiniPhase { thisPhase =>
       tree
   }
 
-  override def transformIdent(tree: Ident)(implicit ctx: Context) = {
+  override def transformIdent(tree: Ident)(implicit ctx: Context): Ident = {
     checkUndesiredProperties(tree.symbol, tree.pos)
     currentLevel.enterReference(tree.symbol, tree.pos)
     tree
   }
 
-  override def transformSelect(tree: Select)(implicit ctx: Context) = {
+  override def transformSelect(tree: Select)(implicit ctx: Context): Select = {
     checkUndesiredProperties(tree.symbol, tree.pos)
     tree
   }
 
-  override def transformApply(tree: Apply)(implicit ctx: Context) = {
+  override def transformApply(tree: Apply)(implicit ctx: Context): Apply = {
     if (isSelfConstrCall(tree)) {
       assert(currentLevel.isInstanceOf[LevelInfo], ctx.owner + "/" + i"$tree")
       val level = currentLevel.asInstanceOf[LevelInfo]
@@ -1009,7 +1008,7 @@ class RefChecks extends MiniPhase { thisPhase =>
     tree
   }
 
-  override def transformNew(tree: New)(implicit ctx: Context) = {
+  override def transformNew(tree: New)(implicit ctx: Context): New = {
     val tpe = tree.tpe
     val sym = tpe.typeSymbol
     checkUndesiredProperties(sym, tree.pos)
diff --git a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
index 06ddce362853..c02796a33106 100644
--- a/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
+++ b/compiler/src/dotty/tools/dotc/typer/TypeAssigner.scala
@@ -4,14 +4,13 @@ package typer
 
 import core._
 import ast._
-import Scopes._, Contexts._, Constants._, Types._, Symbols._, Names._, Flags._, Decorators._
-import ErrorReporting._, Annotations._, Denotations._, SymDenotations._, StdNames._, TypeErasure._
+import Contexts._, Constants._, Types._, Symbols._, Names._, Flags._, Decorators._
+import ErrorReporting._, Annotations._, Denotations._, SymDenotations._, StdNames._
 import util.Positions._
 import config.Printers.typr
 import ast.Trees._
 import NameOps._
 import collection.mutable
-import reporting.diagnostic.Message
 import reporting.diagnostic.messages._
 import Checking.checkNoPrivateLeaks
 
@@ -268,7 +267,7 @@ trait TypeAssigner {
    *   - typed child trees it needs to access to cpmpute that type,
    *   - any further information it needs to access to compute that type.
    */
-  def assignType(tree: untpd.Ident, tp: Type)(implicit ctx: Context) =
+  def assignType(tree: untpd.Ident, tp: Type)(implicit ctx: Context): Ident =
     tree.withType(tp)
 
   def assignType(tree: untpd.Select, qual: Tree)(implicit ctx: Context): Select = {
@@ -294,10 +293,10 @@ trait TypeAssigner {
     tree.withType(tp)
   }
 
-  def assignType(tree: untpd.New, tpt: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.New, tpt: Tree)(implicit ctx: Context): New =
     tree.withType(tpt.tpe)
 
-  def assignType(tree: untpd.Literal)(implicit ctx: Context) =
+  def assignType(tree: untpd.Literal)(implicit ctx: Context): Literal =
     tree.withType {
       val value = tree.const
       value.tag match {
@@ -307,14 +306,14 @@ trait TypeAssigner {
       }
     }
 
-  def assignType(tree: untpd.This)(implicit ctx: Context) = {
+  def assignType(tree: untpd.This)(implicit ctx: Context): This = {
     val cls = qualifyingClass(tree, tree.qual.name, packageOK = false)
     tree.withType(
         if (cls.isClass) cls.thisType
         else errorType("not a legal qualifying class for this", tree.pos))
   }
 
-  def assignType(tree: untpd.Super, qual: Tree, inConstrCall: Boolean, mixinClass: Symbol = NoSymbol)(implicit ctx: Context) = {
+  def assignType(tree: untpd.Super, qual: Tree, inConstrCall: Boolean, mixinClass: Symbol = NoSymbol)(implicit ctx: Context): Super = {
     val mix = tree.mix
     qual.tpe match {
       case err: ErrorType => untpd.cpy.Super(tree)(qual, mix).withType(err)
@@ -343,7 +342,7 @@ trait TypeAssigner {
   /** Substitute argument type `argType` for parameter `pref` in type `tp`,
    *  skolemizing the argument type if it is not stable and `pref` occurs in `tp`.
    */
-  def safeSubstParam(tp: Type, pref: ParamRef, argType: Type)(implicit ctx: Context) = {
+  def safeSubstParam(tp: Type, pref: ParamRef, argType: Type)(implicit ctx: Context): Type = {
     val tp1 = tp.substParam(pref, argType)
     if ((tp1 eq tp) || argType.isStable) tp1
     else tp.substParam(pref, SkolemType(argType.widen))
@@ -361,7 +360,7 @@ trait TypeAssigner {
       tp
     }
 
-  def assignType(tree: untpd.Apply, fn: Tree, args: List[Tree])(implicit ctx: Context) = {
+  def assignType(tree: untpd.Apply, fn: Tree, args: List[Tree])(implicit ctx: Context): Apply = {
     val ownType = fn.tpe.widen match {
       case fntpe: MethodType =>
         if (sameLength(fntpe.paramInfos, args) || ctx.phase.prev.relaxedTyping)
@@ -375,7 +374,7 @@ trait TypeAssigner {
     tree.withType(ownType)
   }
 
-  def assignType(tree: untpd.TypeApply, fn: Tree, args: List[Tree])(implicit ctx: Context) = {
+  def assignType(tree: untpd.TypeApply, fn: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = {
     val ownType = fn.tpe.widen match {
       case pt: TypeLambda =>
         val paramNames = pt.paramNames
@@ -437,30 +436,30 @@ trait TypeAssigner {
     tree.withType(ownType)
   }
 
-  def assignType(tree: untpd.Typed, tpt: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.Typed, tpt: Tree)(implicit ctx: Context): Typed =
     tree.withType(tpt.tpe)
 
-  def assignType(tree: untpd.NamedArg, arg: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.NamedArg, arg: Tree)(implicit ctx: Context): NamedArg =
     tree.withType(arg.tpe)
 
-  def assignType(tree: untpd.Assign)(implicit ctx: Context) =
+  def assignType(tree: untpd.Assign)(implicit ctx: Context): Assign =
     tree.withType(defn.UnitType)
 
-  def assignType(tree: untpd.Block, stats: List[Tree], expr: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.Block, stats: List[Tree], expr: Tree)(implicit ctx: Context): Block =
     tree.withType(avoidingType(expr, stats))
 
-  def assignType(tree: untpd.Inlined, bindings: List[Tree], expansion: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.Inlined, bindings: List[Tree], expansion: Tree)(implicit ctx: Context): Inlined =
     tree.withType(avoidingType(expansion, bindings))
 
-  def assignType(tree: untpd.If, thenp: Tree, elsep: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.If, thenp: Tree, elsep: Tree)(implicit ctx: Context): If =
     tree.withType(thenp.tpe | elsep.tpe)
 
-  def assignType(tree: untpd.Closure, meth: Tree, target: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.Closure, meth: Tree, target: Tree)(implicit ctx: Context): Closure =
     tree.withType(
       if (target.isEmpty) meth.tpe.widen.toFunctionType(tree.env.length)
       else target.tpe)
 
-  def assignType(tree: untpd.CaseDef, pat: Tree, body: Tree)(implicit ctx: Context) = {
+  def assignType(tree: untpd.CaseDef, pat: Tree, body: Tree)(implicit ctx: Context): CaseDef = {
     val ownType =
       if (body.isType) {
         val params = new TreeAccumulator[mutable.ListBuffer[TypeSymbol]] {
@@ -477,23 +476,23 @@ trait TypeAssigner {
     tree.withType(ownType)
   }
 
-  def assignType(tree: untpd.Match, scrutinee: Tree, cases: List[CaseDef])(implicit ctx: Context) =
+  def assignType(tree: untpd.Match, scrutinee: Tree, cases: List[CaseDef])(implicit ctx: Context): Match =
     tree.withType(ctx.typeComparer.lub(cases.tpes))
 
-  def assignType(tree: untpd.Labeled)(implicit ctx: Context) =
+  def assignType(tree: untpd.Labeled)(implicit ctx: Context): Labeled =
     tree.withType(tree.bind.symbol.info)
 
-  def assignType(tree: untpd.Return)(implicit ctx: Context) =
+  def assignType(tree: untpd.Return)(implicit ctx: Context): Return =
     tree.withType(defn.NothingType)
 
-  def assignType(tree: untpd.WhileDo)(implicit ctx: Context) =
+  def assignType(tree: untpd.WhileDo)(implicit ctx: Context): WhileDo =
     tree.withType(defn.UnitType)
 
-  def assignType(tree: untpd.Try, expr: Tree, cases: List[CaseDef])(implicit ctx: Context) =
+  def assignType(tree: untpd.Try, expr: Tree, cases: List[CaseDef])(implicit ctx: Context): Try =
     if (cases.isEmpty) tree.withType(expr.tpe)
     else tree.withType(ctx.typeComparer.lub(expr.tpe :: cases.tpes))
 
-  def assignType(tree: untpd.SeqLiteral, elems: List[Tree], elemtpt: Tree)(implicit ctx: Context) = {
+  def assignType(tree: untpd.SeqLiteral, elems: List[Tree], elemtpt: Tree)(implicit ctx: Context): SeqLiteral = {
     val ownType = tree match {
       case tree: untpd.JavaSeqLiteral => defn.ArrayOf(elemtpt.tpe)
       case _ => if (ctx.erasedTypes) defn.SeqType else defn.SeqType.appliedTo(elemtpt.tpe)
@@ -501,19 +500,19 @@ trait TypeAssigner {
     tree.withType(ownType)
   }
 
-  def assignType(tree: untpd.SingletonTypeTree, ref: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.SingletonTypeTree, ref: Tree)(implicit ctx: Context): SingletonTypeTree =
     tree.withType(ref.tpe)
 
-  def assignType(tree: untpd.AndTypeTree, left: Tree, right: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.AndTypeTree, left: Tree, right: Tree)(implicit ctx: Context): AndTypeTree =
     tree.withType(AndType(left.tpe, right.tpe))
 
-  def assignType(tree: untpd.OrTypeTree, left: Tree, right: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.OrTypeTree, left: Tree, right: Tree)(implicit ctx: Context): OrTypeTree =
     tree.withType(OrType(left.tpe, right.tpe))
 
   /** Assign type of RefinedType.
    *  Refinements are typed as if they were members of refinement class `refineCls`.
    */
-  def assignType(tree: untpd.RefinedTypeTree, parent: Tree, refinements: List[Tree], refineCls: ClassSymbol)(implicit ctx: Context) = {
+  def assignType(tree: untpd.RefinedTypeTree, parent: Tree, refinements: List[Tree], refineCls: ClassSymbol)(implicit ctx: Context): RefinedTypeTree = {
     def addRefinement(parent: Type, refinement: Tree): Type = {
       val rsym = refinement.symbol
       val rinfo = if (rsym is Accessor) rsym.info.resultType else rsym.info
@@ -525,7 +524,7 @@ trait TypeAssigner {
     tree.withType(RecType.closeOver(rt => refined.substThis(refineCls, rt.recThis)))
   }
 
-  def assignType(tree: untpd.AppliedTypeTree, tycon: Tree, args: List[Tree])(implicit ctx: Context) = {
+  def assignType(tree: untpd.AppliedTypeTree, tycon: Tree, args: List[Tree])(implicit ctx: Context): AppliedTypeTree = {
     assert(!hasNamedArg(args))
     val tparams = tycon.tpe.typeParams
     val ownType =
@@ -534,49 +533,49 @@ trait TypeAssigner {
     tree.withType(ownType)
   }
 
-  def assignType(tree: untpd.LambdaTypeTree, tparamDefs: List[TypeDef], body: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.LambdaTypeTree, tparamDefs: List[TypeDef], body: Tree)(implicit ctx: Context): LambdaTypeTree =
     tree.withType(HKTypeLambda.fromParams(tparamDefs.map(_.symbol.asType), body.tpe))
 
-  def assignType(tree: untpd.MatchTypeTree, bound: Tree, scrutinee: Tree, cases: List[CaseDef])(implicit ctx: Context) = {
+  def assignType(tree: untpd.MatchTypeTree, bound: Tree, scrutinee: Tree, cases: List[CaseDef])(implicit ctx: Context): MatchTypeTree = {
     val boundType = if (bound.isEmpty) defn.AnyType else bound.tpe
     tree.withType(MatchType(boundType, scrutinee.tpe, cases.tpes))
   }
 
-  def assignType(tree: untpd.ByNameTypeTree, result: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.ByNameTypeTree, result: Tree)(implicit ctx: Context): ByNameTypeTree =
     tree.withType(ExprType(result.tpe))
 
-  def assignType(tree: untpd.TypeBoundsTree, lo: Tree, hi: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.TypeBoundsTree, lo: Tree, hi: Tree)(implicit ctx: Context): TypeBoundsTree =
     tree.withType(if (lo eq hi) TypeAlias(lo.tpe) else TypeBounds(lo.tpe, hi.tpe))
 
-  def assignType(tree: untpd.Bind, sym: Symbol)(implicit ctx: Context) =
+  def assignType(tree: untpd.Bind, sym: Symbol)(implicit ctx: Context): Bind =
     tree.withType(NamedType(NoPrefix, sym))
 
-  def assignType(tree: untpd.Alternative, trees: List[Tree])(implicit ctx: Context) =
+  def assignType(tree: untpd.Alternative, trees: List[Tree])(implicit ctx: Context): Alternative =
     tree.withType(ctx.typeComparer.lub(trees.tpes))
 
-  def assignType(tree: untpd.UnApply, proto: Type)(implicit ctx: Context) =
+  def assignType(tree: untpd.UnApply, proto: Type)(implicit ctx: Context): UnApply =
     tree.withType(proto)
 
-  def assignType(tree: untpd.ValDef, sym: Symbol)(implicit ctx: Context) =
+  def assignType(tree: untpd.ValDef, sym: Symbol)(implicit ctx: Context): ValDef =
     tree.withType(if (sym.exists) assertExists(sym.termRef) else NoType)
 
-  def assignType(tree: untpd.DefDef, sym: Symbol)(implicit ctx: Context) =
+  def assignType(tree: untpd.DefDef, sym: Symbol)(implicit ctx: Context): DefDef =
     tree.withType(sym.termRef)
 
-  def assignType(tree: untpd.TypeDef, sym: Symbol)(implicit ctx: Context) =
+  def assignType(tree: untpd.TypeDef, sym: Symbol)(implicit ctx: Context): TypeDef =
     tree.withType(sym.typeRef)
 
-  def assertExists(tp: Type) = { assert(tp != NoType); tp }
+  def assertExists(tp: Type): Type = { assert(tp != NoType); tp }
 
-  def assignType(tree: untpd.Import, sym: Symbol)(implicit ctx: Context) =
+  def assignType(tree: untpd.Import, sym: Symbol)(implicit ctx: Context): Import =
     tree.withType(sym.termRef)
 
-  def assignType(tree: untpd.Annotated, arg: Tree, annot: Tree)(implicit ctx: Context) = {
+  def assignType(tree: untpd.Annotated, arg: Tree, annot: Tree)(implicit ctx: Context): Annotated = {
     assert(tree.isType) // annotating a term is done via a Typed node, can't use Annotate directly
     tree.withType(AnnotatedType(arg.tpe, Annotation(annot)))
   }
 
-  def assignType(tree: untpd.PackageDef, pid: Tree)(implicit ctx: Context) =
+  def assignType(tree: untpd.PackageDef, pid: Tree)(implicit ctx: Context): PackageDef =
     tree.withType(pid.symbol.termRef)
 
 }
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 6f7dde5baa70..d9e33c624994 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -11,7 +11,6 @@ import Scopes._
 import Denotations._
 import ProtoTypes._
 import Contexts._
-import Comments._
 import Symbols._
 import Types._
 import SymDenotations._
@@ -27,7 +26,7 @@ import Inferencing._
 import EtaExpansion.etaExpand
 import util.Positions._
 import util.common._
-import util.{Property, SourcePosition}
+import util.Property
 
 import collection.mutable
 import annotation.tailrec
@@ -39,10 +38,7 @@ import NavigateAST._
 import transform.SymUtils._
 import transform.TypeUtils._
 import reporting.trace
-import config.Config
 
-import language.implicitConversions
-import printing.SyntaxHighlighting._
 
 object Typer {
 
@@ -50,16 +46,16 @@ object Typer {
    *  accessed by an Ident.
    */
   object BindingPrec {
-    val definition = 4
-    val namedImport = 3
-    val wildImport = 2
-    val packageClause = 1
-    val nothingBound = 0
-    def isImportPrec(prec: Int) = prec == namedImport || prec == wildImport
+    val definition: Int = 4
+    val namedImport: Int = 3
+    val wildImport: Int = 2
+    val packageClause: Int = 1
+    val nothingBound: Int = 0
+    def isImportPrec(prec: Int): Boolean = prec == namedImport || prec == wildImport
   }
 
   /** Assert tree has a position, unless it is empty or a typed splice */
-  def assertPositioned(tree: untpd.Tree)(implicit ctx: Context) =
+  def assertPositioned(tree: untpd.Tree)(implicit ctx: Context): Unit =
     if (!tree.isEmpty && !tree.isInstanceOf[untpd.TypedSplice] && ctx.typerState.isGlobalCommittable)
       assert(tree.pos.exists, s"position not set for $tree # ${tree.uniqueId}")
 
@@ -91,7 +87,6 @@ class Typer extends Namer
   import Typer._
   import tpd.{cpy => _, _}
   import untpd.cpy
-  import Dynamic.isDynamicMethod
   import reporting.diagnostic.Message
   import reporting.diagnostic.messages._
 
@@ -493,7 +488,7 @@ class Typer extends Namer
     else tree1
   }
 
-  def typedNew(tree: untpd.New, pt: Type)(implicit ctx: Context) = track("typedNew") {
+  def typedNew(tree: untpd.New, pt: Type)(implicit ctx: Context): Tree = track("typedNew") {
     tree.tpt match {
       case templ: untpd.Template =>
         import untpd._
@@ -584,7 +579,7 @@ class Typer extends Namer
    *  exists, rewrite to `ctag(e)`.
    *  @pre We are in pattern-matching mode (Mode.Pattern)
    */
-  def tryWithClassTag(tree: Typed, pt: Type)(implicit ctx: Context) = tree.tpt.tpe.dealias match {
+  def tryWithClassTag(tree: Typed, pt: Type)(implicit ctx: Context): Tree = tree.tpt.tpe.dealias match {
     case tref: TypeRef if !tref.symbol.isClass && !ctx.isAfterTyper =>
       require(ctx.mode.is(Mode.Pattern))
       inferImplicit(defn.ClassTagType.appliedTo(tref),
@@ -597,12 +592,12 @@ class Typer extends Namer
     case _ => tree
   }
 
-  def typedNamedArg(tree: untpd.NamedArg, pt: Type)(implicit ctx: Context) = track("typedNamedArg") {
+  def typedNamedArg(tree: untpd.NamedArg, pt: Type)(implicit ctx: Context): NamedArg = track("typedNamedArg") {
     val arg1 = typed(tree.arg, pt)
     assignType(cpy.NamedArg(tree)(tree.name, arg1), arg1)
   }
 
-  def typedAssign(tree: untpd.Assign, pt: Type)(implicit ctx: Context) = track("typedAssign") {
+  def typedAssign(tree: untpd.Assign, pt: Type)(implicit ctx: Context): Tree = track("typedAssign") {
     tree.lhs match {
       case lhs @ Apply(fn, args) =>
         typed(untpd.Apply(untpd.Select(fn, nme.update), args :+ tree.rhs), pt)
@@ -664,7 +659,7 @@ class Typer extends Namer
   def typedBlockStats(stats: List[untpd.Tree])(implicit ctx: Context): (Context, List[tpd.Tree]) =
     (index(stats), typedStats(stats, ctx.owner))
 
-  def typedBlock(tree: untpd.Block, pt: Type)(implicit ctx: Context) = track("typedBlock") {
+  def typedBlock(tree: untpd.Block, pt: Type)(implicit ctx: Context): Tree = track("typedBlock") {
     val (exprCtx, stats1) = typedBlockStats(tree.stats)
     val expr1 = typedExpr(tree.expr, pt.notApplied)(exprCtx)
     ensureNoLocalRefs(
@@ -753,12 +748,12 @@ class Typer extends Namer
     }
   }
 
-  def typedFunction(tree: untpd.Function, pt: Type)(implicit ctx: Context) = track("typedFunction") {
+  def typedFunction(tree: untpd.Function, pt: Type)(implicit ctx: Context): Tree = track("typedFunction") {
     if (ctx.mode is Mode.Type) typedFunctionType(tree, pt)
     else typedFunctionValue(tree, pt)
   }
 
-  def typedFunctionType(tree: untpd.Function, pt: Type)(implicit ctx: Context) = {
+  def typedFunctionType(tree: untpd.Function, pt: Type)(implicit ctx: Context): Tree = {
     val untpd.Function(args, body) = tree
     val (isImplicit, isErased) = tree match {
       case tree: untpd.FunctionWithMods =>
@@ -803,7 +798,7 @@ class Typer extends Namer
     }
   }
 
-  def typedFunctionValue(tree: untpd.Function, pt: Type)(implicit ctx: Context) = {
+  def typedFunctionValue(tree: untpd.Function, pt: Type)(implicit ctx: Context): Tree = {
     val untpd.Function(params: List[untpd.ValDef] @unchecked, body) = tree
 
     val isImplicit = tree match {
@@ -1009,7 +1004,7 @@ class Typer extends Namer
   }
 
   /** Context with fresh GADT bounds for all gadtSyms */
-  def gadtContext(gadtSyms: Set[Symbol])(implicit ctx: Context) = {
+  def gadtContext(gadtSyms: Set[Symbol])(implicit ctx: Context): Context = {
     val gadtCtx = ctx.fresh.setFreshGADTBounds
     for (sym <- gadtSyms)
       if (!gadtCtx.gadt.bounds.contains(sym))
@@ -1017,7 +1012,7 @@ class Typer extends Namer
     gadtCtx
   }
 
-  def typedCases(cases: List[untpd.CaseDef], selType: Type, pt: Type)(implicit ctx: Context) = {
+  def typedCases(cases: List[untpd.CaseDef], selType: Type, pt: Type)(implicit ctx: Context): List[CaseDef] = {
     val gadts = gadtSyms(selType)
     cases.mapconserve(typedCase(_, selType, pt, gadts))
   }
@@ -1685,7 +1680,7 @@ class Typer extends Namer
   }
 
   /** Overridden in retyper */
-  def checkVariance(tree: Tree)(implicit ctx: Context) = VarianceChecker.check(tree)
+  def checkVariance(tree: Tree)(implicit ctx: Context): Unit = VarianceChecker.check(tree)
 
   def localDummy(cls: ClassSymbol, impl: untpd.Template)(implicit ctx: Context): Symbol =
     ctx.newLocalDummy(cls, impl.pos)
@@ -1798,7 +1793,7 @@ class Typer extends Namer
   }
 
   /** Translate tuples of all arities */
-  def typedTuple(tree: untpd.Tuple, pt: Type)(implicit ctx: Context) = {
+  def typedTuple(tree: untpd.Tuple, pt: Type)(implicit ctx: Context): Tree = {
     val elems = tree.trees
     val arity = elems.length
     if (arity <= Definitions.MaxTupleArity)
@@ -1829,7 +1824,7 @@ class Typer extends Namer
   }
 
   /** Retrieve symbol attached to given tree */
-  protected def retrieveSym(tree: untpd.Tree)(implicit ctx: Context) = tree.removeAttachment(SymOfTree) match {
+  protected def retrieveSym(tree: untpd.Tree)(implicit ctx: Context): Symbol = tree.removeAttachment(SymOfTree) match {
     case Some(sym) =>
       sym.ensureCompleted()
       sym
@@ -1981,7 +1976,7 @@ class Typer extends Namer
   def typedTrees(trees: List[untpd.Tree])(implicit ctx: Context): List[Tree] =
     trees mapconserve (typed(_))
 
-  def typedStats(stats: List[untpd.Tree], exprOwner: Symbol)(implicit ctx: Context): List[tpd.Tree] = {
+  def typedStats(stats: List[untpd.Tree], exprOwner: Symbol)(implicit ctx: Context): List[Tree] = {
     val buf = new mutable.ListBuffer[Tree]
     val enumContexts = new mutable.HashMap[Symbol, Context]
       // A map from `enum` symbols to the contexts enclosing their definitions
@@ -2053,7 +2048,7 @@ class Typer extends Namer
   def typedPattern(tree: untpd.Tree, selType: Type = WildcardType)(implicit ctx: Context): Tree =
     typed(tree, selType)(ctx addMode Mode.Pattern)
 
-  def tryEither[T](op: Context => T)(fallBack: (T, TyperState) => T)(implicit ctx: Context) = {
+  def tryEither[T](op: Context => T)(fallBack: (T, TyperState) => T)(implicit ctx: Context): T = {
     val nestedCtx = ctx.fresh.setNewTyperState()
     val result = op(nestedCtx)
     if (nestedCtx.reporter.hasErrors)
diff --git a/compiler/src/dotty/tools/dotc/typer/VarianceChecker.scala b/compiler/src/dotty/tools/dotc/typer/VarianceChecker.scala
index 869ed3e87d56..871b77809f23 100644
--- a/compiler/src/dotty/tools/dotc/typer/VarianceChecker.scala
+++ b/compiler/src/dotty/tools/dotc/typer/VarianceChecker.scala
@@ -3,12 +3,11 @@ package typer
 
 import dotty.tools.dotc.ast.{ Trees, tpd }
 import core._
-import Types._, Contexts._, Flags._, Symbols._, Annotations._, Trees._, NameOps._
+import Types._, Contexts._, Flags._, Symbols._, Trees._
 import Decorators._
 import Variances._
 import NameKinds._
 import util.Positions._
-import rewrites.Rewrites.patch
 import config.Printers.variances
 import reporting.trace
 
@@ -18,7 +17,7 @@ import reporting.trace
  */
 object VarianceChecker {
   case class VarianceError(tvar: Symbol, required: Variance)
-  def check(tree: tpd.Tree)(implicit ctx: Context) =
+  def check(tree: tpd.Tree)(implicit ctx: Context): Unit =
     new VarianceChecker()(ctx).Traverser.traverse(tree)
 }
 
diff --git a/compiler/src/dotty/tools/dotc/typer/Variances.scala b/compiler/src/dotty/tools/dotc/typer/Variances.scala
index e0e6b79b44a7..014c23c961ee 100644
--- a/compiler/src/dotty/tools/dotc/typer/Variances.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Variances.scala
@@ -1,17 +1,14 @@
 package dotty.tools.dotc
 package typer
 
-import dotty.tools.dotc.ast.{Trees, tpd}
 import core._
-import Types._, Contexts._, Flags._, Symbols._, Annotations._, Trees._
-import Decorators._
+import Types._, Contexts._, Flags._, Symbols._, Annotations._
 
 object Variances {
-  import tpd._
 
   type Variance = FlagSet
-  val Bivariant = VarianceFlags
-  val Invariant = EmptyFlags
+  val Bivariant: Variance = VarianceFlags
+  val Invariant: Variance = EmptyFlags
 
   /** Flip between covariant and contravariant */
   def flip(v: Variance): Variance = {
@@ -24,7 +21,7 @@ object Variances {
   def cut(v: Variance): Variance =
     if (v == Bivariant) v else Invariant
 
-  def compose(v: Variance, boundsVariance: Int) =
+  def compose(v: Variance, boundsVariance: Int): Variance =
     if (boundsVariance == 1) v
     else if (boundsVariance == -1) flip(v)
     else cut(v)
@@ -104,12 +101,12 @@ object Variances {
       Bivariant
   }
 
-  def varianceString(v: Variance) =
+  def varianceString(v: Variance): String =
     if (v is Covariant) "covariant"
     else if (v is Contravariant) "contravariant"
     else "invariant"
 
-  def varianceString(v: Int) =
+  def varianceString(v: Int): String =
     if (v > 0) "+"
     else if (v < 0) "-"
     else ""
diff --git a/compiler/src/dotty/tools/dotc/util/Attachment.scala b/compiler/src/dotty/tools/dotc/util/Attachment.scala
index 270f8a96956d..0fed105d3c91 100644
--- a/compiler/src/dotty/tools/dotc/util/Attachment.scala
+++ b/compiler/src/dotty/tools/dotc/util/Attachment.scala
@@ -106,7 +106,7 @@ object Attachment {
       next = new Link(key, value, next)
     }
 
-    final def removeAllAttachments() =
+    final def removeAllAttachments(): Unit =
       next = null
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/util/Chars.scala b/compiler/src/dotty/tools/dotc/util/Chars.scala
index 14b6fd0dbf89..9620fa2b8859 100644
--- a/compiler/src/dotty/tools/dotc/util/Chars.scala
+++ b/compiler/src/dotty/tools/dotc/util/Chars.scala
@@ -50,17 +50,17 @@ object Chars {
   }
 
   /** Is character a line break? */
-  def isLineBreakChar(c: Char) = (c: @switch) match {
+  def isLineBreakChar(c: Char): Boolean = (c: @switch) match {
     case LF|FF|CR|SU  => true
     case _            => false
   }
 
   /** Is character a whitespace character (but not a new line)? */
-  def isWhitespace(c: Char) =
+  def isWhitespace(c: Char): Boolean =
     c == ' ' || c == '\t' || c == CR
 
   /** Can character form part of a doc comment variable $xxx? */
-  def isVarPart(c: Char) =
+  def isVarPart(c: Char): Boolean =
     '0' <= c && c <= '9' || 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z'
 
   /** Can character start an alphanumeric Scala identifier? */
@@ -68,19 +68,19 @@ object Chars {
     (c == '_') || (c == '$') || JCharacter.isUnicodeIdentifierStart(c)
 
   /** Can character form part of an alphanumeric Scala identifier? */
-  def isIdentifierPart(c: Char) =
+  def isIdentifierPart(c: Char): Boolean =
     (c == '$') || JCharacter.isUnicodeIdentifierPart(c)
 
   /** Is character a math or other symbol in Unicode?  */
-  def isSpecial(c: Char) = {
+  def isSpecial(c: Char): Boolean = {
     val chtp = JCharacter.getType(c)
     chtp == JCharacter.MATH_SYMBOL.toInt || chtp == JCharacter.OTHER_SYMBOL.toInt
   }
 
-  def isValidJVMChar(c: Char) =
+  def isValidJVMChar(c: Char): Boolean =
     !(c == '.' || c == ';' || c =='[' || c == '/')
 
-  def isValidJVMMethodChar(c: Char) =
+  def isValidJVMMethodChar(c: Char): Boolean =
     !(c == '.' || c == ';' || c =='[' || c == '/' || c == '<' || c == '>')
 
   private final val otherLetters = Set[Char]('\u0024', '\u005F')  // '$' and '_'
@@ -88,7 +88,7 @@ object Chars {
     import JCharacter._
     Set[Byte](LOWERCASE_LETTER, UPPERCASE_LETTER, OTHER_LETTER, TITLECASE_LETTER, LETTER_NUMBER)
   }
-  def isScalaLetter(ch: Char) = letterGroups(JCharacter.getType(ch).toByte) || otherLetters(ch)
+  def isScalaLetter(ch: Char): Boolean = letterGroups(JCharacter.getType(ch).toByte) || otherLetters(ch)
 
   /** Can character form part of a Scala operator name? */
   def isOperatorPart(c : Char) : Boolean = (c: @switch) match {
diff --git a/compiler/src/dotty/tools/dotc/util/CommentParsing.scala b/compiler/src/dotty/tools/dotc/util/CommentParsing.scala
index 59b3c61b1155..9e97a724ba75 100644
--- a/compiler/src/dotty/tools/dotc/util/CommentParsing.scala
+++ b/compiler/src/dotty/tools/dotc/util/CommentParsing.scala
@@ -130,7 +130,7 @@ object CommentParsing {
   /** The first start tag of a list of tag intervals,
    *  or the end of the whole comment string - 2 if list is empty
    */
-  def startTag(str: String, sections: List[(Int, Int)]) = sections match {
+  def startTag(str: String, sections: List[(Int, Int)]): Int = sections match {
     case Nil             => str.length - 2
     case (start, _) :: _ => start
   }
@@ -216,7 +216,7 @@ object CommentParsing {
   }
 
   /** Cleanup section text */
-  def cleanupSectionText(str: String) = {
+  def cleanupSectionText(str: String): String = {
     var result = str.trim.replaceAll("\n\\s+\\*\\s+", " \n")
     while (result.endsWith("\n"))
       result = result.substring(0, str.length - 1)
diff --git a/compiler/src/dotty/tools/dotc/util/DiffUtil.scala b/compiler/src/dotty/tools/dotc/util/DiffUtil.scala
index ea49ef2391f1..38b283c1a9eb 100644
--- a/compiler/src/dotty/tools/dotc/util/DiffUtil.scala
+++ b/compiler/src/dotty/tools/dotc/util/DiffUtil.scala
@@ -5,9 +5,9 @@ import scala.collection.mutable
 
 object DiffUtil {
 
-  val EOF = new String("EOF") // Unique string up to reference
+  val EOF: String = new String("EOF") // Unique string up to reference
 
-  val ansiColorToken = '\u001b'
+  val ansiColorToken: Char = '\u001b'
 
   @tailrec private def splitTokens(str: String, acc: List[String] = Nil): List[String] = {
       if (str == "") {
diff --git a/compiler/src/dotty/tools/dotc/util/FreshNameCreator.scala b/compiler/src/dotty/tools/dotc/util/FreshNameCreator.scala
index 5882eb4b9cd9..f3375028c95f 100644
--- a/compiler/src/dotty/tools/dotc/util/FreshNameCreator.scala
+++ b/compiler/src/dotty/tools/dotc/util/FreshNameCreator.scala
@@ -13,8 +13,8 @@ abstract class FreshNameCreator {
 
 object FreshNameCreator {
   class Default extends FreshNameCreator {
-    protected var counter = 0
-    protected val counters = mutable.AnyRefMap[String, Int]() withDefaultValue 0
+    protected var counter: Int = 0
+    protected val counters: mutable.Map[String, Int] = mutable.AnyRefMap() withDefaultValue 0
 
     /**
      * Create a fresh name with the given prefix. It is guaranteed
diff --git a/compiler/src/dotty/tools/dotc/util/HashSet.scala b/compiler/src/dotty/tools/dotc/util/HashSet.scala
index 4b2d46ba0d52..024383af4f89 100644
--- a/compiler/src/dotty/tools/dotc/util/HashSet.scala
+++ b/compiler/src/dotty/tools/dotc/util/HashSet.scala
@@ -11,8 +11,8 @@ class HashSet[T >: Null <: AnyRef](powerOfTwoInitialCapacity: Int, loadFactor: F
   protected def isEqual(x: T, y: T): Boolean = x.equals(y)
 
   // Counters for Stats
-  var accesses = 0
-  var misses = 0
+  var accesses: Int = 0
+  var misses: Int = 0
 
   clear()
 
@@ -99,7 +99,7 @@ class HashSet[T >: Null <: AnyRef](powerOfTwoInitialCapacity: Int, loadFactor: F
   }
 
   /** The iterator of all elements in the set */
-  def iterator = new Iterator[T] {
+  def iterator: Iterator[T] = new Iterator[T] {
     private[this] var i = 0
     def hasNext: Boolean = {
       while (i < table.length && (table(i) eq null)) i += 1
@@ -159,5 +159,5 @@ class HashSet[T >: Null <: AnyRef](powerOfTwoInitialCapacity: Int, loadFactor: F
     }
   }
 
-  override def toString() = "HashSet(%d / %d)".format(used, table.length)
+  override def toString(): String = "HashSet(%d / %d)".format(used, table.length)
 }
diff --git a/compiler/src/dotty/tools/dotc/util/LRUCache.scala b/compiler/src/dotty/tools/dotc/util/LRUCache.scala
index 5f53e81c41a6..cc54519fe1fc 100644
--- a/compiler/src/dotty/tools/dotc/util/LRUCache.scala
+++ b/compiler/src/dotty/tools/dotc/util/LRUCache.scala
@@ -17,13 +17,13 @@ import annotation.tailrec
  */
 class LRUCache[Key >: Null <: AnyRef : ClassTag, Value >: Null: ClassTag] {
   import LRUCache._
-  val keys = new Array[Key](Retained)
-  val values = new Array[Value](Retained)
-  var next = new SixteenNibbles(initialRing.bits)
-  var last = Retained - 1 // value is arbitrary
+  val keys: Array[Key] = new Array[Key](Retained)
+  val values: Array[Value] = new Array(Retained)
+  var next: SixteenNibbles = new SixteenNibbles(initialRing.bits)
+  var last: Int = Retained - 1 // value is arbitrary
   var lastButOne: Int = last - 1
 
-  def first = next(last)
+  def first: Int = next(last)
 
   /** Lookup key, returning value or `null` for not found.
    *  As a side effect, sets `lastButOne` to the element before `last`
@@ -78,7 +78,7 @@ class LRUCache[Key >: Null <: AnyRef : ClassTag, Value >: Null: ClassTag] {
   def keysIterator: Iterator[Key] =
     indices take Retained map keys filter (_ != null)
 
-  override def toString = {
+  override def toString: String = {
     val assocs = keysIterator
       .toList  // double reverse so that lookups do not perturb order
       .reverse
@@ -91,10 +91,10 @@ class LRUCache[Key >: Null <: AnyRef : ClassTag, Value >: Null: ClassTag] {
 object LRUCache {
 
   /** The number of retained elements in the cache; must be at most 16. */
-  val Retained = 16
+  val Retained: Int = 16
 
   /** The initial ring: 0 -> 1 -> ... -> 7 -> 0 */
-  val initialRing =
+  val initialRing: SixteenNibbles =
     (new SixteenNibbles(0L) /: (0 until Retained))((nibbles, idx) =>
       nibbles.updated(idx, (idx + 1) % Retained))
 }
diff --git a/compiler/src/dotty/tools/dotc/util/NameTransformer.scala b/compiler/src/dotty/tools/dotc/util/NameTransformer.scala
index 65e9fef8ddb8..e75d91c64b35 100644
--- a/compiler/src/dotty/tools/dotc/util/NameTransformer.scala
+++ b/compiler/src/dotty/tools/dotc/util/NameTransformer.scala
@@ -3,7 +3,6 @@ package dotc
 package util
 
 import core.Names._
-import core.Decorators._
 import collection.mutable
 import util.Chars.isValidJVMMethodChar
 
@@ -46,7 +45,7 @@ object NameTransformer {
   /** Expand characters that are illegal as JVM method names by `$u`, followed
    *  by the character's unicode expansion.
    */
-  def avoidIllegalChars(name: SimpleName) = {
+  def avoidIllegalChars(name: SimpleName): SimpleName = {
     var i = name.length - 1
     while (i >= 0 && isValidJVMMethodChar(name(i))) i -= 1
     if (i >= 0)
diff --git a/compiler/src/dotty/tools/dotc/util/Positions.scala b/compiler/src/dotty/tools/dotc/util/Positions.scala
index e9302df7d3f8..1e6814d7caf4 100644
--- a/compiler/src/dotty/tools/dotc/util/Positions.scala
+++ b/compiler/src/dotty/tools/dotc/util/Positions.scala
@@ -21,7 +21,7 @@ object Positions {
   /** Convert offset `x` to an integer by sign extending the original
    *  field of `StartEndBits` width.
    */
-  def offsetToInt(x: Int) =
+  def offsetToInt(x: Int): Int =
     x << (32 - StartEndBits) >> (32 - StartEndBits)
 
   /** A position indicates a range between a start offset and an end offset.
@@ -33,7 +33,7 @@ object Positions {
   class Position(val coords: Long) extends AnyVal {
 
     /** Is this position different from NoPosition? */
-    def exists = this != NoPosition
+    def exists: Boolean = this != NoPosition
 
     /** The start of this position. */
     def start: Int = {
@@ -55,16 +55,16 @@ object Positions {
     }
 
     /** The difference between point and start in this position */
-    def pointDelta =
+    def pointDelta: Int =
       (coords >>> (StartEndBits * 2)).toInt
 
-    def orElse(that: Position) =
+    def orElse(that: Position): Position =
       if (this.exists) this else that
 
     /** The union of two positions. This is the least range that encloses
      *  both positions. It is always a synthetic position.
      */
-    def union(that: Position) =
+    def union(that: Position): Position =
       if (!this.exists) that
       else if (!that.exists) this
       else Position(this.start min that.start, this.end max that.end, this.point)
@@ -74,49 +74,49 @@ object Positions {
       !that.exists || exists && (start <= that.start && end >= that.end)
 
     /** Is this position synthetic? */
-    def isSynthetic = pointDelta == SyntheticPointDelta
+    def isSynthetic: Boolean = pointDelta == SyntheticPointDelta
 
     /** Is this position source-derived? */
-    def isSourceDerived = !isSynthetic
+    def isSourceDerived: Boolean = !isSynthetic
 
     /** Is this a zero-extent position? */
-    def isZeroExtent = start == end
+    def isZeroExtent: Boolean = start == end
 
      /** A position where all components are shifted by a given `offset`
      *  relative to this position.
      */
-    def shift(offset: Int) =
+    def shift(offset: Int): Position =
       if (exists) fromOffsets(start + offset, end + offset, pointDelta)
       else this
 
     /** The zero-extent position with start and end at the point of this position */
-    def focus = if (exists) Position(point) else NoPosition
+    def focus: Position = if (exists) Position(point) else NoPosition
 
     /** The zero-extent position with start and end at the start of this position */
-    def startPos = if (exists) Position(start) else NoPosition
+    def startPos: Position = if (exists) Position(start) else NoPosition
 
     /** The zero-extent position with start and end at the end of this position */
-    def endPos = if (exists) Position(end) else NoPosition
+    def endPos: Position = if (exists) Position(end) else NoPosition
 
     /** A copy of this position with a different start */
-    def withStart(start: Int) =
+    def withStart(start: Int): Position =
       if (exists) fromOffsets(start, this.end, if (isSynthetic) SyntheticPointDelta else this.point - start)
       else this
 
     /** A copy of this position with a different end */
-    def withEnd(end: Int) =
+    def withEnd(end: Int): Position =
       if (exists) fromOffsets(this.start, end, pointDelta)
       else this
 
     /** A copy of this position with a different point */
-    def withPoint(point: Int) =
+    def withPoint(point: Int): Position =
       if (exists) fromOffsets(this.start, this.end, point - this.start)
       else this
 
     /** A synthetic copy of this position */
-    def toSynthetic = if (isSynthetic) this else Position(start, end)
+    def toSynthetic: Position = if (isSynthetic) this else Position(start, end)
 
-    override def toString = {
+    override def toString: String = {
       val (left, right) = if (isSynthetic) ("<", ">") else ("[", "]")
       if (exists)
         s"$left$start..${if (point == start) "" else s"$point.."}$end$right"
@@ -147,19 +147,19 @@ object Positions {
   def Position(start: Int): Position = Position(start, start)
 
   /** A sentinel for a non-existing position */
-  val NoPosition = Position(1, 0)
+  val NoPosition: Position = Position(1, 0)
 
   /** The coordinate of a symbol. This is either an index or
    *  a zero-range position.
    */
   class Coord(val encoding: Int) extends AnyVal {
-    def isIndex = encoding > 0
-    def isPosition = encoding <= 0
+    def isIndex: Boolean = encoding > 0
+    def isPosition: Boolean = encoding <= 0
     def toIndex: Int = {
       assert(isIndex)
       encoding - 1
     }
-    def toPosition = {
+    def toPosition: Position = {
       assert(isPosition)
       if (this == NoCoord) NoPosition else Position(-1 - encoding)
     }
@@ -172,5 +172,5 @@ object Positions {
     else NoCoord
 
   /** A sentinel for a missing coordinate */
-  val NoCoord = new Coord(0)
+  val NoCoord: Coord = new Coord(0)
 }
diff --git a/compiler/src/dotty/tools/dotc/util/Set.scala b/compiler/src/dotty/tools/dotc/util/Set.scala
index 4ed1865ce60e..3a8fe9e823aa 100644
--- a/compiler/src/dotty/tools/dotc/util/Set.scala
+++ b/compiler/src/dotty/tools/dotc/util/Set.scala
@@ -17,7 +17,7 @@ abstract class Set[T >: Null] {
   def contains(x: T): Boolean =
     findEntry(x) != null
 
-  def toList = iterator.toList
+  def toList: List[T] = iterator.toList
 
   def clear(): Unit
 }
diff --git a/compiler/src/dotty/tools/dotc/util/ShowPickled.scala b/compiler/src/dotty/tools/dotc/util/ShowPickled.scala
index a0939141f804..e210f80c73e4 100644
--- a/compiler/src/dotty/tools/dotc/util/ShowPickled.scala
+++ b/compiler/src/dotty/tools/dotc/util/ShowPickled.scala
@@ -1,7 +1,7 @@
 package dotty.tools.dotc
 package util
 
-import java.io.{File, FileInputStream, PrintStream}
+import java.io.PrintStream
 import java.lang.Long.toHexString
 import java.lang.Float.intBitsToFloat
 import java.lang.Double.longBitsToDouble
@@ -12,24 +12,24 @@ object ShowPickled {
   import core.unpickleScala2.PickleFormat._
 
   case class PickleBufferEntry(num: Int, startIndex: Int, tag: Int, bytes: Array[Byte]) {
-    def isName = tag == TERMname || tag == TYPEname
-    def hasName = tag match {
+    def isName: Boolean = tag == TERMname || tag == TYPEname
+    def hasName: Boolean = tag match {
       case TYPEsym | ALIASsym | CLASSsym | MODULEsym | VALsym | EXTref | EXTMODCLASSref => true
       case _                                                                            => false
     }
-    def readName =
+    def readName: String =
       if (isName) new String(bytes, "UTF-8")
       else sys.error("%s is no name" format tagName)
-    def nameIndex =
+    def nameIndex: Int =
       if (hasName) readNat(bytes, 0)
       else sys.error("%s has no name" format tagName)
 
-    def tagName = tag2string(tag)
-    override def toString = "%d,%d: %s".format(num, startIndex, tagName)
+    def tagName: String = tag2string(tag)
+    override def toString: String = "%d,%d: %s".format(num, startIndex, tagName)
   }
 
   case class PickleBufferEntryList(entries: IndexedSeq[PickleBufferEntry]) {
-    def nameAt(idx: Int) = {
+    def nameAt(idx: Int): String = {
       val entry = entries(idx)
       if (entry.isName) entry.readName
       else if (entry.hasName) entries(entry.nameIndex).readName
@@ -37,7 +37,7 @@ object ShowPickled {
     }
   }
 
-  def makeEntryList(buf: PickleBuffer, index: Array[Int]) = {
+  def makeEntryList(buf: PickleBuffer, index: Array[Int]): PickleBufferEntryList = {
     val entries = buf.toIndexedSeq.zipWithIndex map {
       case ((tag, data), num) => PickleBufferEntry(num, index(num), tag, data)
     }
diff --git a/compiler/src/dotty/tools/dotc/util/SimpleIdentityMap.scala b/compiler/src/dotty/tools/dotc/util/SimpleIdentityMap.scala
index bdbba5605141..d609b889497f 100644
--- a/compiler/src/dotty/tools/dotc/util/SimpleIdentityMap.scala
+++ b/compiler/src/dotty/tools/dotc/util/SimpleIdentityMap.scala
@@ -20,7 +20,7 @@ abstract class SimpleIdentityMap[K <: AnyRef, +V >: Null <: AnyRef] extends (K =
   }
   def keys: List[K] = map2((k, v) => k)
   def toList: List[(K, V)] = map2((k, v) => (k, v))
-  override def toString = {
+  override def toString: String = {
     def assocToString(key: K, value: V) = s"$key -> $value"
     map2(assocToString) mkString ("(", ", ", ")")
   }
@@ -39,106 +39,106 @@ object SimpleIdentityMap {
     def foreachBinding(f: (AnyRef, Null) => Unit) = ()
   }
 
-  def Empty[K <: AnyRef] = myEmpty.asInstanceOf[SimpleIdentityMap[K, Null]]
+  def Empty[K <: AnyRef]: SimpleIdentityMap[K, Null] = myEmpty.asInstanceOf[SimpleIdentityMap[K, Null]]
 
   class Map1[K <: AnyRef, +V >: Null <: AnyRef] (k1: K, v1: V) extends SimpleIdentityMap[K, V] {
-    def size = 1
-    def apply(k: K) =
+    def size: Int = 1
+    def apply(k: K): V =
       if (k eq k1) v1
       else null
-    def remove(k: K) =
+    def remove(k: K): SimpleIdentityMap[K, V] =
       if (k eq k1) Empty.asInstanceOf[SimpleIdentityMap[K, V]]
       else this
-    def updated[V1 >: V <: AnyRef](k: K, v: V1) =
+    def updated[V1 >: V <: AnyRef](k: K, v: V1): SimpleIdentityMap[K, V1] =
       if (k eq k1) new Map1(k, v)
       else new Map2(k1, v1, k, v)
-    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1) = {
+    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1): SimpleIdentityMap[K, V1] = {
       val w1 = f(k1, v1)
       if (v1 eq w1) this else new Map1(k1, w1)
     }
-    def foreachBinding(f: (K, V) => Unit) = f(k1, v1)
+    def foreachBinding(f: (K, V) => Unit): Unit = f(k1, v1)
   }
 
   class Map2[K <: AnyRef, +V >: Null <: AnyRef] (k1: K, v1: V, k2: K, v2: V) extends SimpleIdentityMap[K, V] {
-    def size = 2
-    def apply(k: K) =
+    def size: Int = 2
+    def apply(k: K): V =
       if (k eq k1) v1
       else if (k eq k2) v2
       else null
-    def remove(k: K) =
+    def remove(k: K): SimpleIdentityMap[K, V] =
       if (k eq k1) new Map1(k2, v2)
       else if (k eq k2) new Map1(k1, v1)
       else this
-    def updated[V1 >: V <: AnyRef](k: K, v: V1) =
+    def updated[V1 >: V <: AnyRef](k: K, v: V1): SimpleIdentityMap[K, V1] =
       if (k eq k1) new Map2(k, v, k2, v2)
       else if (k eq k2) new Map2(k1, v1, k, v)
       else new Map3(k1, v1, k2, v2, k, v)
-    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1) = {
+    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1): SimpleIdentityMap[K, V1] = {
       val w1 = f(k1, v1); val w2 = f(k2, v2)
       if ((v1 eq w1) && (v2 eq w2)) this
       else new Map2(k1, w1, k2, w2)
     }
-    def foreachBinding(f: (K, V) => Unit) = { f(k1, v1); f(k2, v2) }
+    def foreachBinding(f: (K, V) => Unit): Unit = { f(k1, v1); f(k2, v2) }
   }
 
   class Map3[K <: AnyRef, +V >: Null <: AnyRef] (k1: K, v1: V, k2: K, v2: V, k3: K, v3: V) extends SimpleIdentityMap[K, V] {
-    def size = 3
-    def apply(k: K) =
+    def size: Int = 3
+    def apply(k: K): V =
       if (k eq k1) v1
       else if (k eq k2) v2
       else if (k eq k3) v3
       else null
-    def remove(k: K) =
+    def remove(k: K): SimpleIdentityMap[K, V] =
       if (k eq k1) new Map2(k2, v2, k3, v3)
       else if (k eq k2) new Map2(k1, v1, k3, v3)
       else if (k eq k3) new Map2(k1, v1, k2, v2)
       else this
-    def updated[V1 >: V <: AnyRef](k: K, v: V1) =
+    def updated[V1 >: V <: AnyRef](k: K, v: V1): SimpleIdentityMap[K, V1] =
       if (k eq k1) new Map3(k, v, k2, v2, k3, v3)
       else if (k eq k2) new Map3(k1, v1, k, v, k3, v3)
       else if (k eq k3) new Map3(k1, v1, k2, v2, k, v)
       else new Map4(k1, v1, k2, v2, k3, v3, k, v)
-    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1) = {
+    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1): SimpleIdentityMap[K, V1] = {
       val w1 = f(k1, v1); val w2 = f(k2, v2); val w3 = f(k3, v3)
       if ((v1 eq w1) && (v2 eq w2) && (v3 eq w3)) this
       else new Map3(k1, w1, k2, w2, k3, w3)
     }
-    def foreachBinding(f: (K, V) => Unit) = { f(k1, v1); f(k2, v2); f(k3, v3) }
+    def foreachBinding(f: (K, V) => Unit): Unit = { f(k1, v1); f(k2, v2); f(k3, v3) }
   }
 
   class Map4[K <: AnyRef, +V >: Null <: AnyRef] (k1: K, v1: V, k2: K, v2: V, k3: K, v3: V, k4: K, v4: V) extends SimpleIdentityMap[K, V] {
-    def size = 4
-    def apply(k: K) =
+    def size: Int = 4
+    def apply(k: K): V =
       if (k eq k1) v1
       else if (k eq k2) v2
       else if (k eq k3) v3
       else if (k eq k4) v4
       else null
-    def remove(k: K) =
+    def remove(k: K): SimpleIdentityMap[K, V] =
       if (k eq k1) new Map3(k2, v2, k3, v3, k4, v4)
       else if (k eq k2) new Map3(k1, v1, k3, v3, k4, v4)
       else if (k eq k3) new Map3(k1, v1, k2, v2, k4, v4)
       else if (k eq k4) new Map3(k1, v1, k2, v2, k3, v3)
       else this
-    def updated[V1 >: V <: AnyRef](k: K, v: V1) =
+    def updated[V1 >: V <: AnyRef](k: K, v: V1): SimpleIdentityMap[K, V1] =
       if (k eq k1) new Map4(k, v, k2, v2, k3, v3, k4, v4)
       else if (k eq k2) new Map4(k1, v1, k, v, k3, v3, k4, v4)
       else if (k eq k3) new Map4(k1, v1, k2, v2, k, v, k4, v4)
       else if (k eq k4) new Map4(k1, v1, k2, v2, k3, v3, k, v)
       else new MapMore(Array[AnyRef](k1, v1, k2, v2, k3, v3, k4, v4, k, v))
-    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1) = {
+    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1): SimpleIdentityMap[K, V1] = {
       val w1 = f(k1, v1); val w2 = f(k2, v2); val w3 = f(k3, v3); val w4 = f(k4, v4)
       if ((v1 eq w1) && (v2 eq w2) && (v3 eq w3) && (v4 eq w4)) this
       else new Map4(k1, w1, k2, w2, k3, w3, k4, w4)
     }
-    def foreachBinding(f: (K, V) => Unit) = { f(k1, v1); f(k2, v2); f(k3, v3); f(k4, v4) }
+    def foreachBinding(f: (K, V) => Unit): Unit = { f(k1, v1); f(k2, v2); f(k3, v3); f(k4, v4) }
   }
 
   class MapMore[K <: AnyRef, +V >: Null <: AnyRef](bindings: Array[AnyRef]) extends SimpleIdentityMap[K, V] {
     private def key(i: Int): K = bindings(i).asInstanceOf[K]
     private def value(i: Int): V = bindings(i + 1).asInstanceOf[V]
 
-    def size = bindings.length / 2
+    def size: Int = bindings.length / 2
 
     def apply(k: K): V = {
       var i = 0
@@ -200,7 +200,7 @@ object SimpleIdentityMap {
       false
     }
 
-    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1) = {
+    def mapValuesNow[V1 >: V <: AnyRef](f: (K, V1) => V1): SimpleIdentityMap[K, V1] = {
       var bindings1: Array[AnyRef] = bindings
       var i = 0
       while (i < bindings.length) {
@@ -215,7 +215,7 @@ object SimpleIdentityMap {
       if (bindings1 eq bindings) this else new MapMore(bindings1)
     }
 
-    def foreachBinding(f: (K, V) => Unit) = {
+    def foreachBinding(f: (K, V) => Unit): Unit = {
       var i = 0
       while (i < bindings.length) {
         f(key(i), value(i))
diff --git a/compiler/src/dotty/tools/dotc/util/SimpleIdentitySet.scala b/compiler/src/dotty/tools/dotc/util/SimpleIdentitySet.scala
index 8968f7196f73..1d4b4d0a3b1b 100644
--- a/compiler/src/dotty/tools/dotc/util/SimpleIdentitySet.scala
+++ b/compiler/src/dotty/tools/dotc/util/SimpleIdentitySet.scala
@@ -16,16 +16,16 @@ abstract class SimpleIdentitySet[+Elem <: AnyRef] {
     foreach(buf += _)
     buf.toList
   }
-  def ++ [E >: Elem <: AnyRef](that: SimpleIdentitySet[E]) =
+  def ++ [E >: Elem <: AnyRef](that: SimpleIdentitySet[E]): SimpleIdentitySet[E] =
     ((this: SimpleIdentitySet[E]) /: that.toList)(_ + _)
-  def -- [E >: Elem <: AnyRef](that: SimpleIdentitySet[E]) =
+  def -- [E >: Elem <: AnyRef](that: SimpleIdentitySet[E]): SimpleIdentitySet[Elem] =
     (this /: that.toList)(_ - _)
-  override def toString = toList.mkString("(", ", ", ")")
+  override def toString: String = toList.mkString("(", ", ", ")")
 }
 
 object SimpleIdentitySet {
   object empty extends SimpleIdentitySet[Nothing] {
-    def size = 0
+    def size: Int = 0
     def + [E <: AnyRef](x: E): SimpleIdentitySet[E] =
       new Set1[E](x)
     def - [E <: AnyRef](x: E): SimpleIdentitySet[Nothing] =
diff --git a/compiler/src/dotty/tools/dotc/util/SixteenNibbles.scala b/compiler/src/dotty/tools/dotc/util/SixteenNibbles.scala
index 93817604e6b0..ebeb9f700273 100644
--- a/compiler/src/dotty/tools/dotc/util/SixteenNibbles.scala
+++ b/compiler/src/dotty/tools/dotc/util/SixteenNibbles.scala
@@ -17,12 +17,12 @@ class SixteenNibbles(val bits: Long) extends AnyVal {
 
   def elements: IndexedSeq[Int] = (0 until 16) map apply
 
-  override def toString =
+  override def toString: String =
     s"SixteenNibbles(${elements.mkString(", ")})"
 }
 
 object SixteenNibbles {
   final val Width = 4
   final val Mask = (1 << Width) - 1
-  final val LongMask = Mask.toLong
+  final val LongMask: Long = Mask.toLong
 }
diff --git a/compiler/src/dotty/tools/dotc/util/SourceFile.scala b/compiler/src/dotty/tools/dotc/util/SourceFile.scala
index d7cafdaba633..3c0b234a17cc 100644
--- a/compiler/src/dotty/tools/dotc/util/SourceFile.scala
+++ b/compiler/src/dotty/tools/dotc/util/SourceFile.scala
@@ -4,11 +4,9 @@ package util
 
 import scala.collection.mutable.ArrayBuffer
 import dotty.tools.io._
-import annotation.tailrec
 import java.util.regex.Pattern
 import java.io.IOException
 import Chars._
-import ScriptSourceFile._
 import Positions._
 import scala.io.Codec
 import scala.annotation.internal.sharable
@@ -19,7 +17,7 @@ object ScriptSourceFile {
   @sharable private val headerPattern = Pattern.compile("""^(::)?!#.*(\r|\n|\r\n)""", Pattern.MULTILINE)
   private val headerStarts  = List("#!", "::#!")
 
-  def apply(file: AbstractFile, content: Array[Char]) = {
+  def apply(file: AbstractFile, content: Array[Char]): SourceFile = {
     /** Length of the script header from the given content, if there is one.
      *  The header begins with "#!" or "::#!" and ends with a line starting
      *  with "!#" or "::!#".
@@ -42,21 +40,21 @@ case class SourceFile(file: AbstractFile, content: Array[Char]) extends interfac
   def this(name: String, content: String) = this(new VirtualFile(name), content.toCharArray)
 
   /** Tab increment; can be overridden */
-  def tabInc = 8
+  def tabInc: Int = 8
 
-  override def name = file.name
-  override def path = file.path
-  override def jfile = Optional.ofNullable(file.file)
+  override def name: String = file.name
+  override def path: String = file.path
+  override def jfile: Optional[JFile] = Optional.ofNullable(file.file)
 
-  override def equals(that : Any) = that match {
+  override def equals(that : Any): Boolean = that match {
     case that : SourceFile => file.path == that.file.path && start == that.start
     case _ => false
   }
-  override def hashCode = file.path.## + start.##
+  override def hashCode: Int = file.path.## + start.##
 
-  def apply(idx: Int) = content.apply(idx)
+  def apply(idx: Int): Char = content.apply(idx)
 
-  val length = content.length
+  val length: Int = content.length
 
   /** true for all source files except `NoSource` */
   def exists: Boolean = true
@@ -65,13 +63,13 @@ case class SourceFile(file: AbstractFile, content: Array[Char]) extends interfac
   def underlying: SourceFile = this
 
   /** The start of this file in the underlying source file */
-  def start = 0
+  def start: Int = 0
 
   def atPos(pos: Position): SourcePosition =
     if (pos.exists) SourcePosition(underlying, pos)
     else NoSourcePosition
 
-  def isSelfContained = underlying eq this
+  def isSelfContained: Boolean = underlying eq this
 
   /** Map a position to a position in the underlying source file.
    *  For regular source files, simply return the argument.
@@ -147,11 +145,11 @@ case class SourceFile(file: AbstractFile, content: Array[Char]) extends interfac
     pad.result()
   }
 
-  override def toString = file.toString
+  override def toString: String = file.toString
 }
 
 @sharable object NoSource extends SourceFile("<no source>", "") {
-  override def exists = false
+  override def exists: Boolean = false
   override def atPos(pos: Position): SourcePosition = NoSourcePosition
 }
 
diff --git a/compiler/src/dotty/tools/dotc/util/SourcePosition.scala b/compiler/src/dotty/tools/dotc/util/SourcePosition.scala
index 06f4ccc6e1f5..24bd8c579fcc 100644
--- a/compiler/src/dotty/tools/dotc/util/SourcePosition.scala
+++ b/compiler/src/dotty/tools/dotc/util/SourcePosition.scala
@@ -14,7 +14,7 @@ extends interfaces.SourcePosition {
   def contains(that: SourcePosition): Boolean =
     this.source == that.source && this.pos.contains(that.pos)
 
-  def exists = pos.exists
+  def exists: Boolean = pos.exists
 
   def lineContent: String = source.lineContent(point)
 
@@ -53,16 +53,16 @@ extends interfaces.SourcePosition {
   def endLine: Int = source.offsetToLine(end)
   def endColumn: Int = source.column(end)
 
-  def withOuter(outer: SourcePosition) = new SourcePosition(source, pos, outer)
+  def withOuter(outer: SourcePosition): SourcePosition = new SourcePosition(source, pos, outer)
 
-  override def toString =
+  override def toString: String =
     if (source.exists) s"${source.file}:${line + 1}"
     else s"(no source file, offset = ${pos.point})"
 }
 
 /** A sentinel for a non-existing source position */
 @sharable object NoSourcePosition extends SourcePosition(NoSource, NoPosition) {
-  override def toString = "?"
-  override def withOuter(outer: SourcePosition) = outer
+  override def toString: String = "?"
+  override def withOuter(outer: SourcePosition): SourcePosition = outer
 }
 
diff --git a/compiler/src/dotty/tools/dotc/util/Stats.scala b/compiler/src/dotty/tools/dotc/util/Stats.scala
index 283fce5279e0..7fec4c75bbcc 100644
--- a/compiler/src/dotty/tools/dotc/util/Stats.scala
+++ b/compiler/src/dotty/tools/dotc/util/Stats.scala
@@ -14,16 +14,16 @@ import collection.mutable
   /** The period in ms in which stack snapshots are displayed */
   final val HeartBeatPeriod = 250
 
-  var monitored = false
+  var monitored: Boolean = false
 
   @volatile private[this] var stack: List[String] = Nil
 
-  val hits = new mutable.HashMap[String, Int] {
+  val hits: mutable.HashMap[String, Int] = new mutable.HashMap[String, Int] {
     override def default(key: String): Int = 0
   }
 
   @forceInline
-  def record(fn: => String, n: => Int = 1) =
+  def record(fn: => String, n: => Int = 1): Unit =
     if (enabled) doRecord(fn, n)
 
   private def doRecord(fn: String, n: Int) =
@@ -33,10 +33,10 @@ import collection.mutable
     }
 
   @forceInline
-  def track[T](fn: String)(op: => T) =
+  def track[T](fn: String)(op: => T): T =
     if (enabled) doTrack(fn)(op) else op
 
-  def doTrack[T](fn: String)(op: => T) =
+  def doTrack[T](fn: String)(op: => T): T =
     if (monitored) {
       stack = fn :: stack
       record(fn)
@@ -45,10 +45,10 @@ import collection.mutable
     } else op
 
   @forceInline
-  def trackTime[T](fn: String)(op: => T) =
+  def trackTime[T](fn: String)(op: => T): T =
     if (enabled) doTrackTime(fn)(op) else op
 
-  def doTrackTime[T](fn: String)(op: => T) = {
+  def doTrackTime[T](fn: String)(op: => T): T = {
     def op1 = op
     if (monitored) {
       val start = System.nanoTime
@@ -57,7 +57,7 @@ import collection.mutable
   }
 
   class HeartBeat extends Thread() {
-    @volatile private[Stats] var continue = true
+    @volatile private[Stats] var continue: Boolean = true
 
     private def printStack(stack: List[String]): Unit = stack match {
       case str :: rest =>
@@ -75,7 +75,7 @@ import collection.mutable
     }
   }
 
-  def maybeMonitored[T](op: => T)(implicit ctx: Context) = {
+  def maybeMonitored[T](op: => T)(implicit ctx: Context): T = {
     if (ctx.settings.YdetailedStats.value) {
       val hb = new HeartBeat()
       if (ctx.settings.Yheartbeat.value) hb.start()
diff --git a/compiler/src/dotty/tools/dotc/util/Util.scala b/compiler/src/dotty/tools/dotc/util/Util.scala
index 0d37f687be11..ffb40caf5292 100644
--- a/compiler/src/dotty/tools/dotc/util/Util.scala
+++ b/compiler/src/dotty/tools/dotc/util/Util.scala
@@ -24,7 +24,7 @@ object Util {
   }
 
   /** An array twice the size of given array, with existing elements copied over */
-  def dble[T: ClassTag](arr: Array[T]) = {
+  def dble[T: ClassTag](arr: Array[T]): Array[T] = {
     val arr1 = new Array[T](arr.length * 2)
     Array.copy(arr, 0, arr1, 0, arr.length)
     arr1
diff --git a/compiler/src/dotty/tools/dotc/util/WeakHashSet.scala b/compiler/src/dotty/tools/dotc/util/WeakHashSet.scala
index 30748013266d..0469fa29d86c 100644
--- a/compiler/src/dotty/tools/dotc/util/WeakHashSet.scala
+++ b/compiler/src/dotty/tools/dotc/util/WeakHashSet.scala
@@ -224,10 +224,10 @@ final class WeakHashSet[A >: Null <: AnyRef](val initialCapacity: Int, val loadF
     }
   }
 
-  def +=(elem: A) = this + elem
+  def +=(elem: A): this.type = this + elem
 
   // from scala.reflect.internal.Set
-  override def addEntry(x: A) = { this += x }
+  override def addEntry(x: A): Unit = { this += x }
 
   // remove an element from this set and return this set
   override def -(elem: A): this.type = elem match {
@@ -250,7 +250,7 @@ final class WeakHashSet[A >: Null <: AnyRef](val initialCapacity: Int, val loadF
     }
   }
 
-  def -=(elem: A) = this - elem
+  def -=(elem: A): this.type = this - elem
 
   // empty this set
   override def clear(): Unit = {
@@ -368,7 +368,7 @@ final class WeakHashSet[A >: Null <: AnyRef](val initialCapacity: Int, val loadF
     /**
      *  Produces a diagnostic dump of the table that underlies this hash set.
      */
-    def dump = table.deep
+    def dump: IndexedSeq[Any] = table.deep
 
     /**
      * Number of buckets that hold collisions. Useful for diagnosing performance issues.
@@ -388,7 +388,7 @@ final class WeakHashSet[A >: Null <: AnyRef](val initialCapacity: Int, val loadF
     def bucketsCount: Int = table.size
   }
 
-  private[util] def diagnostics = new Diagnostics
+  private[util] def diagnostics: Diagnostics = new Diagnostics
 }
 
 /**
@@ -401,9 +401,9 @@ object WeakHashSet {
    */
   private class Entry[A](element: A, val hash:Int, var tail: Entry[A], queue: ReferenceQueue[A]) extends WeakReference[A](element, queue)
 
-  val defaultInitialCapacity = 16
-  val defaultLoadFactor = .75
+  val defaultInitialCapacity: Int = 16
+  val defaultLoadFactor: Double = .75
 
-  def apply[A >: Null <: AnyRef](initialCapacity: Int = WeakHashSet.defaultInitialCapacity, loadFactor: Double = WeakHashSet.defaultLoadFactor) =
+  def apply[A >: Null <: AnyRef](initialCapacity: Int = WeakHashSet.defaultInitialCapacity, loadFactor: Double = WeakHashSet.defaultLoadFactor): WeakHashSet[A] =
     new WeakHashSet[A](initialCapacity, defaultLoadFactor)
 }
diff --git a/compiler/src/dotty/tools/dotc/util/common.scala b/compiler/src/dotty/tools/dotc/util/common.scala
index 7b81416a7f74..dc71214d028a 100644
--- a/compiler/src/dotty/tools/dotc/util/common.scala
+++ b/compiler/src/dotty/tools/dotc/util/common.scala
@@ -1,15 +1,13 @@
 package dotty.tools.dotc
 package util
 
-import core.Names.Name
 import core.Types.WildcardType
 
 /** Common values hoisted out for performance */
 object common {
 
-  val alwaysTrue = Function.const(true) _
-  val alwaysFalse = Function.const(false) _
-  val alwaysZero = Function.const(0) _
-  val alwaysWildcardType = Function.const(WildcardType) _
-
+  val alwaysTrue: Any => Boolean = Function.const(true) _
+  val alwaysFalse: Any => Boolean = Function.const(false) _
+  val alwaysZero: Any => Int = Function.const(0) _
+  val alwaysWildcardType: Any => WildcardType.type = Function.const(WildcardType) _
 }
diff --git a/compiler/src/dotty/tools/io/AbstractFile.scala b/compiler/src/dotty/tools/io/AbstractFile.scala
index 6ab93f7328ce..6d893a275bbc 100644
--- a/compiler/src/dotty/tools/io/AbstractFile.scala
+++ b/compiler/src/dotty/tools/io/AbstractFile.scala
@@ -10,7 +10,7 @@ import java.io.{
   ByteArrayOutputStream
 }
 import java.net.URL
-import java.nio.file.{FileAlreadyExistsException, Files, Paths}
+import java.nio.file.{Files, Paths}
 
 /**
  * An abstraction over files for use in the reflection/compiler libraries.
@@ -93,7 +93,7 @@ abstract class AbstractFile extends Iterable[AbstractFile] {
   def canonicalPath: String = if (jpath == null) path else jpath.normalize.toString
 
   /** Checks extension case insensitively. */
-  def hasExtension(other: String) = extension == other.toLowerCase
+  def hasExtension(other: String): Boolean = extension == other.toLowerCase
   val extension: String = Path.extension(name)
 
   /** The absolute file, if this is a relative file. */
@@ -122,7 +122,7 @@ abstract class AbstractFile extends Iterable[AbstractFile] {
   }
 
   /** Does this abstract file represent something which can contain classfiles? */
-  def isClassContainer = isDirectory || (jpath != null && (extension == "jar" || extension == "zip"))
+  def isClassContainer: Boolean = isDirectory || (jpath != null && (extension == "jar" || extension == "zip"))
 
   /** Create a file on disk, if one does not exist already. */
   def create(): Unit
@@ -158,7 +158,7 @@ abstract class AbstractFile extends Iterable[AbstractFile] {
    *  encoding when converting to the char array.
    */
   @throws(classOf[IOException])
-  def toCharArray = new String(toByteArray).toCharArray
+  def toCharArray: Array[Char] = new String(toByteArray).toCharArray
 
   /** Returns contents of file (if applicable) in a byte array.
    */
@@ -266,6 +266,6 @@ abstract class AbstractFile extends Iterable[AbstractFile] {
   protected def unsupported(msg: String): Nothing = throw new UnsupportedOperationException(msg)
 
   /** Returns the path of this abstract file. */
-  override def toString() = path
+  override def toString(): String = path
 
 }
diff --git a/compiler/src/dotty/tools/io/ClassPath.scala b/compiler/src/dotty/tools/io/ClassPath.scala
index 9b3ee03d167e..6192c6958f47 100644
--- a/compiler/src/dotty/tools/io/ClassPath.scala
+++ b/compiler/src/dotty/tools/io/ClassPath.scala
@@ -95,7 +95,7 @@ trait ClassPath {
 }
 
 object ClassPath {
-  val RootPackage = ""
+  val RootPackage: String = ""
 
   /** Expand single path entry */
   private def expandS(pattern: String): List[String] = {
diff --git a/compiler/src/dotty/tools/io/Directory.scala b/compiler/src/dotty/tools/io/Directory.scala
index 28d936e92666..043d8d44c231 100644
--- a/compiler/src/dotty/tools/io/Directory.scala
+++ b/compiler/src/dotty/tools/io/Directory.scala
@@ -9,9 +9,7 @@
 package dotty.tools.io
 
 import java.nio.file.{Files, Paths}
-import java.util.stream.Collectors
 
-import scala.collection.JavaConverters._
 
 /**
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
diff --git a/compiler/src/dotty/tools/io/File.scala b/compiler/src/dotty/tools/io/File.scala
index 894a928044ce..284e8989a1f5 100644
--- a/compiler/src/dotty/tools/io/File.scala
+++ b/compiler/src/dotty/tools/io/File.scala
@@ -8,10 +8,7 @@
 
 package dotty.tools.io
 
-import java.io.{
-  FileInputStream, FileOutputStream, BufferedWriter, OutputStreamWriter,
-  BufferedOutputStream, IOException, PrintWriter
-}
+import java.io.{File => JavaIoFile, _}
 import java.nio.file.{Files, Paths}
 import java.nio.file.StandardOpenOption._
 
@@ -20,8 +17,8 @@ import scala.io.Codec
  * ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 object File {
-  def pathSeparator = java.io.File.pathSeparator
-  def separator     = java.io.File.separator
+  def pathSeparator: String = JavaIoFile.pathSeparator
+  def separator: String     = JavaIoFile.separator
 
   def apply(path: String)(implicit codec: Codec): File = apply(Paths.get(path))
   def apply(path: JPath)(implicit codec: Codec): File = new File(path)
@@ -39,25 +36,25 @@ object File {
  *  ''Note:  This is library is considered experimental and should not be used unless you know what you are doing.''
  */
 class File(jpath: JPath)(implicit constructorCodec: Codec) extends Path(jpath) with Streamable.Chars {
-  override val creationCodec = constructorCodec
+  override val creationCodec: io.Codec = constructorCodec
 
   override def addExtension(ext: String): File = super.addExtension(ext).toFile
   override def toAbsolute: File = if (isAbsolute) this else super.toAbsolute.toFile
   override def toDirectory: Directory = new Directory(jpath)
   override def toFile: File = this
   override def normalize: File = super.normalize.toFile
-  override def length = super[Path].length
+  override def length: Long = super[Path].length
   override def walkFilter(cond: Path => Boolean): Iterator[Path] =
     if (cond(this)) Iterator.single(this) else Iterator.empty
 
   /** Obtains an InputStream. */
-  def inputStream() = Files.newInputStream(jpath)
+  def inputStream(): InputStream = Files.newInputStream(jpath)
 
   /** Obtains a OutputStream. */
-  def outputStream(append: Boolean = false) =
+  def outputStream(append: Boolean = false): OutputStream =
     if (append) Files.newOutputStream(jpath, CREATE, APPEND)
     else Files.newOutputStream(jpath, CREATE, TRUNCATE_EXISTING)
-  def bufferedOutput(append: Boolean = false) = new BufferedOutputStream(outputStream(append))
+  def bufferedOutput(append: Boolean = false): BufferedOutputStream = new BufferedOutputStream(outputStream(append))
 
   /** Obtains an OutputStreamWriter wrapped around a FileOutputStream.
    *  This should behave like a less broken version of java.io.FileWriter,
diff --git a/compiler/src/dotty/tools/io/Jar.scala b/compiler/src/dotty/tools/io/Jar.scala
index 5e24f486cf13..ec0f54738774 100644
--- a/compiler/src/dotty/tools/io/Jar.scala
+++ b/compiler/src/dotty/tools/io/Jar.scala
@@ -7,11 +7,12 @@
 package dotty.tools
 package io
 
-import java.io.{ InputStream, OutputStream, IOException, FileNotFoundException, FileInputStream, DataOutputStream }
+import java.io.{ InputStream, OutputStream, DataOutputStream }
 import java.util.jar._
 import scala.collection.JavaConverters._
+import scala.collection.mutable
 import Attributes.Name
-import scala.language.{postfixOps, implicitConversions}
+import scala.language.postfixOps
 import scala.annotation.tailrec
 
 // Attributes.Name instances:
@@ -42,10 +43,10 @@ class Jar(file: File) extends Iterable[JarEntry] {
 
   import Jar._
 
-  lazy val jarFile  = new JarFile(file.jpath.toFile)
-  lazy val manifest = withJarInput(s => Option(s.getManifest))
+  lazy val jarFile: JarFile  = new JarFile(file.jpath.toFile)
+  lazy val manifest: Option[Manifest] = withJarInput(s => Option(s.getManifest))
 
-  def mainClass     = manifest map (f => f(Name.MAIN_CLASS))
+  def mainClass: Option[String]     = manifest map (f => f(Name.MAIN_CLASS))
   /** The manifest-defined classpath String if available. */
   def classPathString: Option[String] =
     for (m <- manifest ; cp <- m.attrs get Name.CLASS_PATH) yield cp
@@ -59,7 +60,7 @@ class Jar(file: File) extends Iterable[JarEntry] {
     try f(in)
     finally in.close()
   }
-  def jarWriter(mainAttrs: (Attributes.Name, String)*) = {
+  def jarWriter(mainAttrs: (Attributes.Name, String)*): JarWriter = {
     new JarWriter(file, Jar.WManifest.apply(mainAttrs: _*).underlying)
   }
 
@@ -68,11 +69,11 @@ class Jar(file: File) extends Iterable[JarEntry] {
   }
   override def iterator: Iterator[JarEntry] = this.toList.iterator
 
-  def getEntryStream(entry: JarEntry) = jarFile getInputStream entry match {
+  def getEntryStream(entry: JarEntry): java.io.InputStream = jarFile getInputStream entry match {
     case null   => errorFn("No such entry: " + entry) ; null
     case x      => x
   }
-  override def toString = "" + file
+  override def toString: String = "" + file
 }
 
 class JarWriter(val file: File, val manifest: Manifest) {
@@ -118,7 +119,7 @@ class JarWriter(val file: File, val manifest: Manifest) {
     loop()
   }
 
-  def close() = out.close()
+  def close(): Unit = out.close()
 }
 
 object Jar {
@@ -137,8 +138,8 @@ object Jar {
     for ((k, v) <- initialMainAttrs)
       this(k) = v
 
-    def underlying = manifest
-    def attrs = manifest.getMainAttributes().asInstanceOf[AttributeMap].asScala withDefaultValue null
+    def underlying: JManifest = manifest
+    def attrs: mutable.Map[Name, String] = manifest.getMainAttributes().asInstanceOf[AttributeMap].asScala withDefaultValue null
     def initialMainAttrs: Map[Attributes.Name, String] = {
       import scala.util.Properties._
       Map(
@@ -149,11 +150,11 @@ object Jar {
 
     def apply(name: Attributes.Name): String        = attrs(name)
     def apply(name: String): String                 = apply(new Attributes.Name(name))
-    def update(key: Attributes.Name, value: String) = attrs.put(key, value)
-    def update(key: String, value: String)          = attrs.put(new Attributes.Name(key), value)
+    def update(key: Attributes.Name, value: String): Option[String] = attrs.put(key, value)
+    def update(key: String, value: String): Option[String]          = attrs.put(new Attributes.Name(key), value)
 
     def mainClass: String = apply(Name.MAIN_CLASS)
-    def mainClass_=(value: String) = update(Name.MAIN_CLASS, value)
+    def mainClass_=(value: String): Option[String] = update(Name.MAIN_CLASS, value)
   }
 
   // See http://download.java.net/jdk7/docs/api/java/nio/file/Path.html
diff --git a/compiler/src/dotty/tools/io/NoAbstractFile.scala b/compiler/src/dotty/tools/io/NoAbstractFile.scala
index 3ba5eaff7d3f..e6022ea40633 100644
--- a/compiler/src/dotty/tools/io/NoAbstractFile.scala
+++ b/compiler/src/dotty/tools/io/NoAbstractFile.scala
@@ -28,6 +28,6 @@ object NoAbstractFile extends AbstractFile {
   def name: String = ""
   def output: java.io.OutputStream = null
   def path: String = ""
-  override def toByteArray = Array[Byte]()
-  override def toString = "<no file>"
+  override def toByteArray: Array[Byte] = Array[Byte]()
+  override def toString: String = "<no file>"
 }
diff --git a/compiler/src/dotty/tools/io/Path.scala b/compiler/src/dotty/tools/io/Path.scala
index e5223a580a7d..069472ca6858 100644
--- a/compiler/src/dotty/tools/io/Path.scala
+++ b/compiler/src/dotty/tools/io/Path.scala
@@ -5,11 +5,10 @@
 
 package dotty.tools.io
 
-import scala.language.implicitConversions
 import java.io.RandomAccessFile
 import java.nio.file._
 import java.net.{URI, URL}
-import java.nio.file.attribute.BasicFileAttributes
+import java.nio.file.attribute.{BasicFileAttributes, FileTime}
 import java.io.IOException
 
 import scala.collection.JavaConverters._
@@ -61,8 +60,8 @@ object Path {
   } catch { case ex: SecurityException => new Path(jpath) }
 
   /** Avoiding any shell/path issues by only using alphanumerics. */
-  private[io] def randomPrefix = alphanumeric take 6 mkString ""
-  private[io] def fail(msg: String) = throw FileOperationException(msg)
+  private[io] def randomPrefix: String = alphanumeric take 6 mkString ""
+  private[io] def fail(msg: String): Nothing = throw FileOperationException(msg)
 }
 import Path._
 
@@ -72,8 +71,8 @@ import Path._
  *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 class Path private[io] (val jpath: JPath) {
-  val separator = java.io.File.separatorChar
-  val separatorStr = java.io.File.separator
+  val separator: Char = java.io.File.separatorChar
+  val separatorStr: String = java.io.File.separator
 
   // conversions
   def toFile: File = new File(jpath)
@@ -86,7 +85,7 @@ class Path private[io] (val jpath: JPath) {
   /** If this path is absolute, returns it: otherwise, returns an absolute
    *  path made up of root / this.
    */
-  def toAbsoluteWithRoot(root: Path) = if (isAbsolute) this else root.toAbsolute / this
+  def toAbsoluteWithRoot(root: Path): Path = if (isAbsolute) this else root.toAbsolute / this
 
   /** Creates a new Path with the specified path appended.  Assumes
    *  the type of the new component implies the type of the result.
@@ -121,8 +120,8 @@ class Path private[io] (val jpath: JPath) {
   def path: String = jpath.toString
   def normalize: Path = new Path(jpath.normalize)
 
-  def resolve(other: Path) = new Path(jpath.resolve(other.jpath))
-  def relativize(other: Path) = new Path(jpath.relativize(other.jpath))
+  def resolve(other: Path): Path = new Path(jpath.resolve(other.jpath))
+  def relativize(other: Path): Path = new Path(jpath.relativize(other.jpath))
 
   def segments: List[String] = (path split separator).toList filterNot (_.length == 0)
 
@@ -140,7 +139,7 @@ class Path private[io] (val jpath: JPath) {
   // if name ends with an extension (e.g. "foo.jpg") returns the extension ("jpg"), otherwise ""
   def extension: String = Path.extension(name)
   // compares against extensions in a CASE INSENSITIVE way.
-  def hasExtension(ext: String, exts: String*) = {
+  def hasExtension(ext: String, exts: String*): Boolean = {
     val lower = extension.toLowerCase
     ext.toLowerCase == lower || exts.exists(_.toLowerCase == lower)
   }
@@ -159,24 +158,24 @@ class Path private[io] (val jpath: JPath) {
   def ifDirectory[T](f: Directory => T): Option[T] = if (isDirectory) Some(f(toDirectory)) else None
 
   // Boolean tests
-  def canRead = Files.isReadable(jpath)
-  def canWrite = Files.isWritable(jpath)
-  def exists = try Files.exists(jpath)  catch { case ex: SecurityException => false }
-  def isFile = try Files.isRegularFile(jpath)  catch { case ex: SecurityException => false }
-  def isDirectory =
+  def canRead: Boolean = Files.isReadable(jpath)
+  def canWrite: Boolean = Files.isWritable(jpath)
+  def exists: Boolean = try Files.exists(jpath)  catch { case ex: SecurityException => false }
+  def isFile: Boolean = try Files.isRegularFile(jpath)  catch { case ex: SecurityException => false }
+  def isDirectory: Boolean =
     try Files.isDirectory(jpath)
     catch { case ex: SecurityException => jpath.toString == "." }
-  def isAbsolute = jpath.isAbsolute()
-  def isEmpty = path.length == 0
+  def isAbsolute: Boolean = jpath.isAbsolute()
+  def isEmpty: Boolean = path.length == 0
 
   // Information
-  def lastModified = Files.getLastModifiedTime(jpath)
-  def length = Files.size(jpath)
+  def lastModified: FileTime = Files.getLastModifiedTime(jpath)
+  def length: Long = Files.size(jpath)
 
   // Boolean path comparisons
-  def endsWith(other: Path) = segments endsWith other.segments
-  def isSame(other: Path) = toCanonical == other.toCanonical
-  def isFresher(other: Path) = lastModified.compareTo(other.lastModified) > 0
+  def endsWith(other: Path): Boolean = segments endsWith other.segments
+  def isSame(other: Path): Boolean = toCanonical == other.toCanonical
+  def isFresher(other: Path): Boolean = lastModified.compareTo(other.lastModified) > 0
 
   // creations
   def createDirectory(force: Boolean = true, failIfExists: Boolean = false): Directory = {
@@ -221,7 +220,7 @@ class Path private[io] (val jpath: JPath) {
     }
   }
 
-  def truncate() =
+  def truncate(): Boolean =
     isFile && {
       val raf = new RandomAccessFile(jpath.toFile, "rw")
       raf setLength 0
@@ -229,10 +228,10 @@ class Path private[io] (val jpath: JPath) {
       length == 0
     }
 
-  override def toString() = path
-  override def equals(other: Any) = other match {
+  override def toString(): String = path
+  override def equals(other: Any): Boolean = other match {
     case x: Path  => path == x.path
     case _        => false
   }
-  override def hashCode() = path.hashCode()
+  override def hashCode(): Int = path.hashCode()
 }
diff --git a/compiler/src/dotty/tools/io/PlainFile.scala b/compiler/src/dotty/tools/io/PlainFile.scala
index 9eb2705dd622..f5bde26722fc 100644
--- a/compiler/src/dotty/tools/io/PlainFile.scala
+++ b/compiler/src/dotty/tools/io/PlainFile.scala
@@ -6,12 +6,12 @@
 package dotty.tools
 package io
 
-import java.nio.file.{Files, NotDirectoryException}
+import java.io.{InputStream, OutputStream}
 
 /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
 class PlainDirectory(givenPath: Directory) extends PlainFile(givenPath) {
-  override def isDirectory = true
-  override def iterator() = givenPath.list filter (_.exists) map (x => new PlainFile(x))
+  override def isDirectory: Boolean = true
+  override def iterator(): Iterator[PlainFile] = givenPath.list filter (_.exists) map (x => new PlainFile(x))
   override def delete(): Unit = givenPath.deleteRecursively()
 }
 
@@ -22,24 +22,24 @@ class PlainDirectory(givenPath: Directory) extends PlainFile(givenPath) {
 class PlainFile(val givenPath: Path) extends AbstractFile {
   assert(path ne null)
 
-  def jpath = givenPath.jpath
-  override def underlyingSource = Some(this)
+  def jpath: JPath = givenPath.jpath
+  override def underlyingSource: Some[PlainFile] = Some(this)
 
   private val fpath = givenPath.toAbsolute
 
   /** Returns the name of this abstract file. */
-  def name = givenPath.name
+  def name: String = givenPath.name
 
   /** Returns the path of this abstract file. */
-  def path = givenPath.path
+  def path: String = givenPath.path
 
   /** The absolute file. */
-  def absolute = new PlainFile(givenPath.toAbsolute)
+  def absolute: PlainFile = new PlainFile(givenPath.toAbsolute)
 
   override def container: AbstractFile = new PlainFile(givenPath.parent)
-  override def input = givenPath.toFile.inputStream()
-  override def output = givenPath.toFile.outputStream()
-  override def sizeOption = Some(givenPath.length.toInt)
+  override def input: InputStream = givenPath.toFile.inputStream()
+  override def output: OutputStream = givenPath.toFile.outputStream()
+  override def sizeOption: Option[Int] = Some(givenPath.length.toInt)
 
   override def hashCode(): Int = fpath.hashCode()
   override def equals(that: Any): Boolean = that match {
diff --git a/compiler/src/dotty/tools/io/Streamable.scala b/compiler/src/dotty/tools/io/Streamable.scala
index 7143f04062e3..099e261e7491 100644
--- a/compiler/src/dotty/tools/io/Streamable.scala
+++ b/compiler/src/dotty/tools/io/Streamable.scala
@@ -34,7 +34,7 @@ object Streamable {
     def inputStream(): InputStream
     def length: Long = -1
 
-    def bufferedInput() = new BufferedInputStream(inputStream())
+    def bufferedInput(): BufferedInputStream = new BufferedInputStream(inputStream())
     def bytes(): Iterator[Byte] = bytesAsInts() map (_.toByte)
     def bytesAsInts(): Iterator[Int] = {
       val in = bufferedInput()
@@ -100,7 +100,7 @@ object Streamable {
     /** Wraps a BufferedReader around the result of reader().
      */
     def bufferedReader(): BufferedReader = bufferedReader(creationCodec)
-    def bufferedReader(codec: Codec) = new BufferedReader(reader(codec))
+    def bufferedReader(codec: Codec): BufferedReader = new BufferedReader(reader(codec))
 
     /** Creates a BufferedReader and applies the closure, automatically closing it on completion.
      */
@@ -113,7 +113,7 @@ object Streamable {
     /** Convenience function to import entire file into a String.
      */
     def slurp(): String = slurp(creationCodec)
-    def slurp(codec: Codec) = {
+    def slurp(codec: Codec): String = {
       val src = chars(codec)
       try src.mkString finally src.close()  // Always Be Closing
     }
diff --git a/compiler/src/dotty/tools/io/VirtualDirectory.scala b/compiler/src/dotty/tools/io/VirtualDirectory.scala
index 44d235e26d96..cfd8a66aac42 100644
--- a/compiler/src/dotty/tools/io/VirtualDirectory.scala
+++ b/compiler/src/dotty/tools/io/VirtualDirectory.scala
@@ -5,7 +5,7 @@
 package dotty.tools.io
 
 import scala.collection.mutable
-
+import java.io.{InputStream, OutputStream}
 /**
  * An in-memory directory.
  *
@@ -21,22 +21,22 @@ extends AbstractFile {
       case Some(parent) => parent.path+'/'+ name
     }
 
-  def absolute = this
+  def absolute: AbstractFile = this
 
-  def container = maybeContainer.get
-  def isDirectory = true
-  override def isVirtual = true
+  def container: VirtualDirectory = maybeContainer.get
+  def isDirectory: Boolean = true
+  override def isVirtual: Boolean = true
   val lastModified: Long = System.currentTimeMillis
 
-  override def jpath = null
-  override def input = sys.error("directories cannot be read")
-  override def output = sys.error("directories cannot be written")
+  override def jpath: JPath = null
+  override def input: InputStream = sys.error("directories cannot be read")
+  override def output: OutputStream = sys.error("directories cannot be written")
 
   /** Does this abstract file denote an existing file? */
-  def create() = { unsupported() }
+  def create(): Unit = { unsupported() }
 
   /** Delete the underlying file or directory (recursively). */
-  def delete() = { unsupported() }
+  def delete(): Unit = { unsupported() }
 
   /** Returns an abstract file with the given name. It does not
    *  check that it exists.
@@ -47,7 +47,7 @@ extends AbstractFile {
 
   // the toList is so that the directory may continue to be
   // modified while its elements are iterated
-  def iterator() = files.values.toList.iterator
+  def iterator(): Iterator[AbstractFile] = files.values.toList.iterator
 
   override def lookupName(name: String, directory: Boolean): AbstractFile =
     (files get name filter (_.isDirectory == directory)).orNull
@@ -66,7 +66,7 @@ extends AbstractFile {
       dir
     }
 
-  def clear() = {
+  def clear(): Unit = {
     files.clear()
   }
 }
diff --git a/compiler/src/dotty/tools/io/VirtualFile.scala b/compiler/src/dotty/tools/io/VirtualFile.scala
index 5708b67607c7..8206e50baaf2 100644
--- a/compiler/src/dotty/tools/io/VirtualFile.scala
+++ b/compiler/src/dotty/tools/io/VirtualFile.scala
@@ -24,15 +24,15 @@ class VirtualFile(val name: String, override val path: String) extends AbstractF
    */
   def this(name: String) = this(name, name)
 
-  override def hashCode = path.hashCode
-  override def equals(that: Any) = that match {
+  override def hashCode: Int = path.hashCode
+  override def equals(that: Any): Boolean = that match {
     case x: VirtualFile => x.path == path
     case _              => false
   }
 
   private[this] var content = Array.emptyByteArray
 
-  def absolute = this
+  def absolute: AbstractFile = this
 
   /** Returns null. */
   def jpath: JPath = null
@@ -92,5 +92,5 @@ class VirtualFile(val name: String, override val path: String) extends AbstractF
   /** Returns an abstract file with the given name. It does not
    *  check that it exists.
    */
-  def lookupNameUnchecked(name: String, directory: Boolean) = unsupported()
+  def lookupNameUnchecked(name: String, directory: Boolean): AbstractFile = unsupported()
 }
diff --git a/compiler/src/dotty/tools/io/ZipArchive.scala b/compiler/src/dotty/tools/io/ZipArchive.scala
index d83fd230f0a6..668a2aab8886 100644
--- a/compiler/src/dotty/tools/io/ZipArchive.scala
+++ b/compiler/src/dotty/tools/io/ZipArchive.scala
@@ -6,13 +6,12 @@
 package dotty.tools.io
 
 import java.net.URL
-import java.io.{ IOException, InputStream, ByteArrayInputStream, FilterInputStream }
+import java.io.{ IOException, InputStream, OutputStream, FilterInputStream }
 import java.nio.file.Files
-import java.util.zip.{ ZipEntry, ZipFile, ZipInputStream }
+import java.util.zip.{ ZipEntry, ZipFile }
 import java.util.jar.Manifest
 import scala.collection.mutable
 import scala.collection.JavaConverters._
-import scala.annotation.tailrec
 
 /** An abstraction for zip files and streams.  Everything is written the way
  *  it is for performance: we come through here a lot on every run.  Be careful
@@ -25,7 +24,7 @@ import scala.annotation.tailrec
  *  ''Note:  This library is considered experimental and should not be used unless you know what you are doing.''
  */
 object ZipArchive {
-  private[io] val closeZipFile = sys.props.get("scala.classpath.closeZip").exists(_.toBoolean)
+  private[io] val closeZipFile: Boolean = sys.props.get("scala.classpath.closeZip").exists(_.toBoolean)
 
   /**
    * @param   file  a File
@@ -56,29 +55,29 @@ import ZipArchive._
 abstract class ZipArchive(override val jpath: JPath) extends AbstractFile with Equals {
   self =>
 
-  override def underlyingSource = Some(this)
-  def isDirectory = true
-  def lookupName(name: String, directory: Boolean) = unsupported()
-  def lookupNameUnchecked(name: String, directory: Boolean) = unsupported()
-  def create()  = unsupported()
-  def delete()  = unsupported()
-  def output    = unsupported()
-  def container = unsupported()
-  def absolute  = unsupported()
+  override def underlyingSource: Option[ZipArchive] = Some(this)
+  def isDirectory: Boolean = true
+  def lookupName(name: String, directory: Boolean): AbstractFile = unsupported()
+  def lookupNameUnchecked(name: String, directory: Boolean): AbstractFile = unsupported()
+  def create(): Unit = unsupported()
+  def delete(): Unit = unsupported()
+  def output: OutputStream    = unsupported()
+  def container: AbstractFile = unsupported()
+  def absolute: AbstractFile  = unsupported()
 
   /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
   sealed abstract class Entry(path: String) extends VirtualFile(baseName(path), path) {
     // have to keep this name for compat with sbt's compiler-interface
     def getArchive: ZipFile = null
-    override def underlyingSource = Some(self)
-    override def toString = self.path + "(" + path + ")"
+    override def underlyingSource: Option[ZipArchive] = Some(self)
+    override def toString: String = self.path + "(" + path + ")"
   }
 
   /** ''Note:  This library is considered experimental and should not be used unless you know what you are doing.'' */
   class DirEntry(path: String) extends Entry(path) {
-    val entries = mutable.HashMap[String, Entry]()
+    val entries: mutable.HashMap[String, Entry] = mutable.HashMap()
 
-    override def isDirectory = true
+    override def isDirectory: Boolean = true
     override def iterator: Iterator[Entry] = entries.valuesIterator
     override def lookupName(name: String, directory: Boolean): Entry = {
       if (directory) entries.get(name + "/").orNull
@@ -148,7 +147,7 @@ final class FileZipArchive(jpath: JPath) extends ZipArchive(jpath) {
     override def sizeOption: Option[Int] = Some(zipEntry.getSize.toInt)
   }
 
-  @volatile lazy val (root, allDirs) = {
+  @volatile lazy val (root, allDirs): (DirEntry, collection.Map[String, DirEntry]) = {
     val root = new DirEntry("/")
     val dirs = mutable.HashMap[String, DirEntry]("/" -> root)
     val zipFile = openZipFile()
@@ -181,22 +180,22 @@ final class FileZipArchive(jpath: JPath) extends ZipArchive(jpath) {
 
   def iterator: Iterator[Entry] = root.iterator
 
-  def name         = jpath.getFileName.toString
-  def path         = jpath.toString
-  def input        = Files.newInputStream(jpath)
-  def lastModified = Files.getLastModifiedTime(jpath).toMillis
+  def name: String       = jpath.getFileName.toString
+  def path: String       = jpath.toString
+  def input: InputStream = Files.newInputStream(jpath)
+  def lastModified: Long = Files.getLastModifiedTime(jpath).toMillis
 
-  override def sizeOption = Some(Files.size(jpath).toInt)
-  override def canEqual(other: Any) = other.isInstanceOf[FileZipArchive]
-  override def hashCode() = jpath.hashCode
-  override def equals(that: Any) = that match {
+  override def sizeOption: Option[Int] = Some(Files.size(jpath).toInt)
+  override def canEqual(other: Any): Boolean = other.isInstanceOf[FileZipArchive]
+  override def hashCode(): Int = jpath.hashCode
+  override def equals(that: Any): Boolean = that match {
     case x: FileZipArchive => jpath.toAbsolutePath == x.jpath.toAbsolutePath
     case _                 => false
   }
 }
 
 final class ManifestResources(val url: URL) extends ZipArchive(null) {
-  def iterator() = {
+  def iterator(): Iterator[AbstractFile] = {
     val root     = new DirEntry("/")
     val dirs     = mutable.HashMap[String, DirEntry]("/" -> root)
     val manifest = new Manifest(input)
@@ -218,20 +217,20 @@ final class ManifestResources(val url: URL) extends ZipArchive(null) {
     finally dirs.clear()
   }
 
-  def name  = path
+  def name: String  = path
   def path: String = {
     val s = url.getPath
     val n = s.lastIndexOf('!')
     s.substring(0, n)
   }
-  def input = url.openStream()
-  def lastModified =
+  def input: InputStream = url.openStream()
+  def lastModified: Long =
     try url.openConnection().getLastModified()
     catch { case _: IOException => 0 }
 
-  override def canEqual(other: Any) = other.isInstanceOf[ManifestResources]
-  override def hashCode() = url.hashCode
-  override def equals(that: Any) = that match {
+  override def canEqual(other: Any): Boolean = other.isInstanceOf[ManifestResources]
+  override def hashCode(): Int = url.hashCode
+  override def equals(that: Any): Boolean = that match {
     case x: ManifestResources => url == x.url
     case _                => false
   }
diff --git a/compiler/src/dotty/tools/package.scala b/compiler/src/dotty/tools/package.scala
index aace5e3e7da1..2a7506da8d52 100644
--- a/compiler/src/dotty/tools/package.scala
+++ b/compiler/src/dotty/tools/package.scala
@@ -1,5 +1,4 @@
 package dotty
-import scala.annotation.Annotation
 
 package object tools {
   // Ensure this object is already classloaded, since it's only actually used
@@ -7,7 +6,7 @@ package object tools {
   // risks failing.
   dotty.tools.dotc.core.handleRecursive
 
-  val ListOfNil = Nil :: Nil
+  val ListOfNil: List[Nil.type] = Nil :: Nil
 
   /** True if two lists have the same length.  Since calling length on linear sequences
    *  is O(n), it is an inadvisable way to test length equality.
diff --git a/compiler/src/dotty/tools/repl/CollectTopLevelImports.scala b/compiler/src/dotty/tools/repl/CollectTopLevelImports.scala
index 119810fddc73..a025ccd6f3bb 100644
--- a/compiler/src/dotty/tools/repl/CollectTopLevelImports.scala
+++ b/compiler/src/dotty/tools/repl/CollectTopLevelImports.scala
@@ -13,10 +13,10 @@ import dotty.tools.dotc.core.Phases.Phase
 class CollectTopLevelImports extends Phase {
   import tpd._
 
-  def phaseName = "collectTopLevelImports"
+  def phaseName: String = "collectTopLevelImports"
 
   private[this] var myImports: List[Import] = _
-  def imports = myImports
+  def imports: List[Import] = myImports
 
   def run(implicit ctx: Context): Unit = {
     def topLevelImports(tree: Tree) = {
diff --git a/compiler/src/dotty/tools/repl/JLineTerminal.scala b/compiler/src/dotty/tools/repl/JLineTerminal.scala
index 376fd920992c..681f105e4788 100644
--- a/compiler/src/dotty/tools/repl/JLineTerminal.scala
+++ b/compiler/src/dotty/tools/repl/JLineTerminal.scala
@@ -63,7 +63,7 @@ final class JLineTerminal extends java.io.Closeable {
     lineReader.readLine(prompt)
   }
 
-  def close() = terminal.close()
+  def close(): Unit = terminal.close()
 
   /** Provide syntax highlighting */
   private class Highlighter(implicit ctx: Context) extends reader.Highlighter {
diff --git a/compiler/src/dotty/tools/repl/ParseResult.scala b/compiler/src/dotty/tools/repl/ParseResult.scala
index 2722cd5f6b2e..9d5c89980f53 100644
--- a/compiler/src/dotty/tools/repl/ParseResult.scala
+++ b/compiler/src/dotty/tools/repl/ParseResult.scala
@@ -7,9 +7,7 @@ import dotc.parsing.Parsers.Parser
 import dotc.parsing.Tokens
 import dotc.util.SourceFile
 import dotc.ast.untpd
-import dotc.reporting._
 
-import results._
 
 import scala.annotation.internal.sharable
 
@@ -47,7 +45,7 @@ case class UnknownCommand(cmd: String) extends Command
  */
 case class Load(path: String) extends Command
 object Load {
-  val command = ":load"
+  val command: String = ":load"
 }
 
 /** To find out the type of an expression you may simply do:
@@ -59,7 +57,7 @@ object Load {
  */
 case class TypeOf(expr: String) extends Command
 object TypeOf {
-  val command = ":type"
+  val command: String = ":type"
 }
 
 /**
@@ -68,32 +66,32 @@ object TypeOf {
  */
 case class DocOf(expr: String) extends Command
 object DocOf {
-  val command = ":doc"
+  val command: String = ":doc"
 }
 
 /** `:imports` lists the imports that have been explicitly imported during the
  *  session
  */
 case object Imports extends Command {
-  val command = ":imports"
+  val command: String = ":imports"
 }
 
 /** Reset the session to the initial state from when the repl program was
  *  started
  */
 case object Reset extends Command {
-  val command = ":reset"
+  val command: String = ":reset"
 }
 
 /** `:quit` exits the repl */
 case object Quit extends Command {
-  val command = ":quit"
+  val command: String = ":quit"
 }
 
 /** `:help` shows the different commands implemented by the Dotty repl */
 case object Help extends Command {
-  val command = ":help"
-  val text =
+  val command: String = ":help"
+  val text: String =
     """The REPL has several commands available:
       |
       |:help                    print this summary
diff --git a/compiler/src/dotty/tools/repl/Rendering.scala b/compiler/src/dotty/tools/repl/Rendering.scala
index 65c932b20a9c..e0722395ab1f 100644
--- a/compiler/src/dotty/tools/repl/Rendering.scala
+++ b/compiler/src/dotty/tools/repl/Rendering.scala
@@ -5,9 +5,7 @@ import java.io.{ StringWriter, PrintWriter }
 import java.lang.{ ClassLoader, ExceptionInInitializerError }
 import java.lang.reflect.InvocationTargetException
 
-import scala.util.control.NonFatal
 
-import dotc.core.Types._
 import dotc.core.Contexts.Context
 import dotc.core.Denotations.Denotation
 import dotc.core.Flags
diff --git a/compiler/src/dotty/tools/repl/ReplCompiler.scala b/compiler/src/dotty/tools/repl/ReplCompiler.scala
index cf81040d655d..3f3606ef0906 100644
--- a/compiler/src/dotty/tools/repl/ReplCompiler.scala
+++ b/compiler/src/dotty/tools/repl/ReplCompiler.scala
@@ -8,7 +8,6 @@ import dotty.tools.dotc.core.Contexts._
 import dotty.tools.dotc.core.Decorators._
 import dotty.tools.dotc.core.Flags._
 import dotty.tools.dotc.core.Names._
-import dotty.tools.dotc.core.Phases
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols._
diff --git a/compiler/src/dotty/tools/repl/ReplDriver.scala b/compiler/src/dotty/tools/repl/ReplDriver.scala
index cf26c0f8eec7..63bd7e9dd4a6 100644
--- a/compiler/src/dotty/tools/repl/ReplDriver.scala
+++ b/compiler/src/dotty/tools/repl/ReplDriver.scala
@@ -13,7 +13,6 @@ import dotty.tools.dotc.core.NameOps._
 import dotty.tools.dotc.core.Names.Name
 import dotty.tools.dotc.core.StdNames._
 import dotty.tools.dotc.core.Symbols.{Symbol, defn}
-import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.interactive.Interactive
 import dotty.tools.dotc.printing.SyntaxHighlighting
 import dotty.tools.dotc.reporting.MessageRendering
@@ -60,7 +59,7 @@ class ReplDriver(settings: Array[String],
   /** Overridden to `false` in order to not have to give sources on the
    *  commandline
    */
-  override def sourcesRequired = false
+  override def sourcesRequired: Boolean = false
 
   /** Create a fresh and initialized context with IDE mode enabled */
   private[this] def initialCtx = {
@@ -72,7 +71,7 @@ class ReplDriver(settings: Array[String],
   }
 
   /** the initial, empty state of the REPL session */
-  final def initialState = State(0, 0, Map.empty, rootCtx)
+  final def initialState: State = State(0, 0, Map.empty, rootCtx)
 
   /** Reset state of repl to the initial state
    *
diff --git a/compiler/src/dotty/tools/repl/ReplFrontEnd.scala b/compiler/src/dotty/tools/repl/ReplFrontEnd.scala
index 7f6091729f1c..23ea141d0887 100644
--- a/compiler/src/dotty/tools/repl/ReplFrontEnd.scala
+++ b/compiler/src/dotty/tools/repl/ReplFrontEnd.scala
@@ -13,9 +13,9 @@ import dotc.core.Contexts.Context
  */
 private[repl] class REPLFrontEnd extends FrontEnd {
 
-  override def isRunnable(implicit ctx: Context) = true
+  override def isRunnable(implicit ctx: Context): Boolean = true
 
-  override def runOn(units: List[CompilationUnit])(implicit ctx: Context) = {
+  override def runOn(units: List[CompilationUnit])(implicit ctx: Context): List[CompilationUnit] = {
     assert(units.size == 1) // REPl runs one compilation unit at a time
 
     val unitContext = ctx.fresh.setCompilationUnit(units.head)
diff --git a/compiler/src/dotty/tools/repl/package.scala b/compiler/src/dotty/tools/repl/package.scala
index c79535a5c7e5..9e9d4c24bb5c 100644
--- a/compiler/src/dotty/tools/repl/package.scala
+++ b/compiler/src/dotty/tools/repl/package.scala
@@ -2,7 +2,6 @@ package dotty.tools
 
 import dotc.core.Contexts.Context
 import dotc.core.Symbols.Symbol
-import dotc.reporting.diagnostic.MessageContainer
 import dotc.printing.ReplPrinter
 import dotc.reporting.{HideNonSensicalMessages, StoreReporter, UniqueMessagePositions}
 
diff --git a/compiler/src/scala/reflect/internal/pickling/package.scala b/compiler/src/scala/reflect/internal/pickling/package.scala
index 9940d4369929..773ec113417d 100644
--- a/compiler/src/scala/reflect/internal/pickling/package.scala
+++ b/compiler/src/scala/reflect/internal/pickling/package.scala
@@ -1,6 +1,8 @@
 package scala.reflect.internal
 
+import dotty.tools.dotc.core.unpickleScala2
+
 package object pickling {
-  type PickleBuffer = dotty.tools.dotc.core.unpickleScala2.PickleBuffer
-  val PickleFormat = dotty.tools.dotc.core.unpickleScala2.PickleFormat
+  type PickleBuffer = unpickleScala2.PickleBuffer
+  val PickleFormat: unpickleScala2.PickleFormat.type = unpickleScala2.PickleFormat
 }
diff --git a/compiler/src/scala/tools/nsc/io/package.scala b/compiler/src/scala/tools/nsc/io/package.scala
index f364824c6c83..19e065db8b99 100644
--- a/compiler/src/scala/tools/nsc/io/package.scala
+++ b/compiler/src/scala/tools/nsc/io/package.scala
@@ -11,17 +11,17 @@ package scala.tools.nsc
  */
 package object io {
   type AbstractFile = dotty.tools.io.AbstractFile
-  val AbstractFile = dotty.tools.io.AbstractFile
+  val AbstractFile: dotty.tools.io.AbstractFile.type = dotty.tools.io.AbstractFile
 
   type Directory = dotty.tools.io.Directory
-  val Directory = dotty.tools.io.Directory
+  val Directory: dotty.tools.io.Directory.type = dotty.tools.io.Directory
 
   type Path = dotty.tools.io.Path
-  val Path = dotty.tools.io.Path
+  val Path: dotty.tools.io.Path.type = dotty.tools.io.Path
 
   type File = dotty.tools.io.File
-  val File = dotty.tools.io.File
+  val File: dotty.tools.io.File.type = dotty.tools.io.File
 
   type Jar = dotty.tools.io.Jar
-  val Jar = dotty.tools.io.Jar
+  val Jar: dotty.tools.io.Jar.type = dotty.tools.io.Jar
 }
diff --git a/library/src/dotty/runtime/LazyVals.scala b/library/src/dotty/runtime/LazyVals.scala
index 04114a156c06..513311060e0c 100644
--- a/library/src/dotty/runtime/LazyVals.scala
+++ b/library/src/dotty/runtime/LazyVals.scala
@@ -1,6 +1,5 @@
 package dotty.runtime
 
-import scala.annotation.tailrec
 import scala.forceInline
 
 /**