[WIP] Safe initialization for Scala

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -39,6 +39,7 @@ class Compiler {
     List(new sbt.ExtractDependencies) :: // Sends information on classes' dependencies to sbt via callbacks
     List(new PostTyper) ::          // Additional checks and cleanups after type checking
     List(new sbt.ExtractAPI) ::     // Sends a representation of the API of classes to sbt via callbacks
+    List(new init.Checker) ::        // Check safe initialization of class fields
     Nil
 
   /** Phases dealing with TASTY tree pickling and unpickling */

compiler/src/dotty/tools/dotc/Driver.scala

@@ -40,10 +40,13 @@ class Driver {
       }
     else ctx.reporter
 
+  @scala.annotation.init
   protected def initCtx: Context = (new ContextBase).initialCtx
 
+  @scala.annotation.init
   protected def sourcesRequired: Boolean = true
 
+  @scala.annotation.init
   def setup(args: Array[String], rootCtx: Context): (List[String], Context) = {
     val ctx = rootCtx.fresh
     val summary = CompilerCommand.distill(args)(ctx)

compiler/src/dotty/tools/dotc/Run.scala

@@ -56,7 +56,7 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     ctx.initialize()(start) // re-initialize the base context with start
     def addImport(ctx: Context, refFn: () => TermRef) =
       ctx.fresh.setImportInfo(ImportInfo.rootImport(refFn)(ctx))
-    (start.setRun(this) /: defn.RootImportFns)(addImport)
+    (start.setRun(this: @unchecked) /: defn.RootImportFns)(addImport)
   }
 
   private[this] var compiling = false

compiler/src/dotty/tools/dotc/ast/DesugarEnums.scala

@@ -16,7 +16,7 @@ object DesugarEnums {
   import untpd._
 
   @sharable object CaseKind extends Enumeration {
-    val Simple, Object, Class: Value = Value
+    val Simple, Object, Class: Value = Value : @unchecked
   }
 
   /** Attachment containing the number of enum cases and the smallest kind that was seen so far. */

compiler/src/dotty/tools/dotc/ast/TreeInfo.scala

@@ -559,14 +559,16 @@ trait TypedTreeInfo extends TreeInfo[Type] { self: Trees.Instance[Type] =>
    *
    *  Note: targ and vargss may be empty
    */
-  def decomposeCall(tree: Tree): (Tree, List[Tree], List[List[Tree]]) = {
-    @tailrec
+  def decomposeCall(tree: Tree)(implicit ctx: Context): (Tree, List[Tree], List[List[Tree]]) = {
     def loop(tree: Tree, targss: List[Tree], argss: List[List[Tree]]): (Tree, List[Tree], List[List[Tree]]) =
       tree match {
         case Apply(fn, args) =>
           loop(fn, targss, args :: argss)
         case TypeApply(fn, targs) =>
           loop(fn, targs ::: targss, argss)
+        case Block(stats, expr) =>
+          val (fn, targss2, argss2) = loop(expr, targss, argss)
+          (Block(stats, fn), targss2, argss2)
         case _ =>
           (tree, targss, argss)
       }

compiler/src/dotty/tools/dotc/ast/Trees.scala

@@ -804,7 +804,7 @@ object Trees {
       trees foreach (_.foreachInThicket(op))
   }
 
-  class EmptyValDef[T >: Untyped] extends ValDef[T](
+  final class EmptyValDef[T >: Untyped] extends ValDef[T](
     nme.WILDCARD, genericEmptyTree[T], genericEmptyTree[T]) with WithoutTypeOrPos[T] {
     myTpe = NoType.asInstanceOf[T]
     override def isEmpty: Boolean = true

compiler/src/dotty/tools/dotc/config/Printers.scala

@@ -21,6 +21,7 @@ object Printers {
   val exhaustivity: Printer = noPrinter
   val gadts: Printer = noPrinter
   val hk: Printer = noPrinter
+  val init: Printer = noPrinter
   val implicits: Printer = noPrinter
   val implicitsDetailed: Printer = noPrinter
   val inlining: Printer = noPrinter

compiler/src/dotty/tools/dotc/config/Settings.scala

@@ -255,45 +255,58 @@ object Settings {
     def processArguments(arguments: List[String], processAll: Boolean)(implicit ctx: Context): ArgsSummary =
       processArguments(ArgsSummary(ctx.settingsState, arguments, Nil, Nil), processAll, Nil)
 
+    @scala.annotation.init
     def publish[T](settingf: Int => Setting[T]): Setting[T] = {
       val setting = settingf(_allSettings.length)
       _allSettings += setting
       setting
     }
 
+    @scala.annotation.init
     def BooleanSetting(name: String, descr: String, initialValue: Boolean = false): Setting[Boolean] =
       publish(Setting(name, descr, initialValue))
 
+    @scala.annotation.init
     def StringSetting(name: String, helpArg: String, descr: String, default: String): Setting[String] =
       publish(Setting(name, descr, default, helpArg))
 
+    @scala.annotation.init
     def ChoiceSetting(name: String, helpArg: String, descr: String, choices: List[String], default: String): Setting[String] =
       publish(Setting(name, descr, default, helpArg, choices))
 
+    @scala.annotation.init
     def IntSetting(name: String, descr: String, default: Int, range: Seq[Int] = Nil): Setting[Int] =
       publish(Setting(name, descr, default, choices = range))
 
+    @scala.annotation.init
     def MultiStringSetting(name: String, helpArg: String, descr: String): Setting[List[String]] =
       publish(Setting(name, descr, Nil, helpArg))
 
+    @scala.annotation.init
     def OutputSetting(name: String, helpArg: String, descr: String, default: AbstractFile): Setting[AbstractFile] =
       publish(Setting(name, descr, default, helpArg))
 
+    @scala.annotation.init
     def PathSetting(name: String, descr: String, default: String): Setting[String] =
       publish(Setting(name, descr, default))
 
+    @scala.annotation.init
     def PathSetting(name: String, helpArg: String, descr: String, default: String): Setting[String] =
       publish(Setting(name, descr, default, helpArg))
 
+    @scala.annotation.init
     def PhasesSetting(name: String, descr: String, default: String = ""): Setting[List[String]] =
       publish(Setting(name, descr, if (default.isEmpty) Nil else List(default)))
 
+    @scala.annotation.init
     def PrefixSetting(name: String, pre: String, descr: String): Setting[List[String]] =
       publish(Setting(name, descr, Nil, prefix = pre))
 
+    @scala.annotation.init
     def VersionSetting(name: String, descr: String, default: ScalaVersion = NoScalaVersion): Setting[ScalaVersion] =
       publish(Setting(name, descr, default))
 
+    @scala.annotation.init
     def OptionSetting[T: ClassTag](name: String, descr: String): Setting[Option[T]] =
       publish(Setting(name, descr, None, propertyClass = Some(implicitly[ClassTag[T]].runtimeClass)))
   }

compiler/src/dotty/tools/dotc/config/WrappedProperties.scala

@@ -12,7 +12,7 @@ trait WrappedProperties extends PropertiesTrait {
   def wrap[T](body: => T): Option[T]
 
   protected def propCategory: String     = "wrapped"
-  protected def pickJarBasedOn: Class[_] = this.getClass
+  protected def pickJarBasedOn: Class[_] = this.getClass: @unchecked
 
   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

compiler/src/dotty/tools/dotc/core/Annotations.scala

@@ -177,6 +177,22 @@ object Annotations {
         else None
     }
 
+    /** Extractor for init annotations */
+    object Call {
+      /** A regular, non-deferred Child annotation */
+      def apply(sym: Symbol)(implicit ctx: Context): Annotation = {
+        val tree = New(defn.CallAnnotType.appliedTo(sym.owner.thisType.select(sym.name, sym)), Nil)
+        ConcreteAnnotation(tree)
+      }
+
+      def unapply(ann: Annotation)(implicit ctx: Context): Option[Symbol] =
+        if (ann.symbol == defn.CallAnnot) {
+          val AppliedType(tycon, (arg: NamedType) :: Nil) = ann.tree.tpe
+          Some(arg.symbol)
+        }
+        else None
+    }
+
     def makeSourceFile(path: String)(implicit ctx: Context): Annotation =
       apply(defn.SourceFileAnnot, Literal(Constant(path)))
   }

compiler/src/dotty/tools/dotc/core/Contexts.scala

@@ -89,11 +89,13 @@ object Contexts {
 
     /** The outer context */
     private[this] var _outer: Context = _
+    @scala.annotation.init
     protected def outer_=(outer: Context): Unit = _outer = outer
     def outer: Context = _outer
 
     /** The current context */
     private[this] var _period: Period = _
+    @scala.annotation.init
     protected def period_=(period: Period): Unit = {
       assert(period.firstPhaseId == period.lastPhaseId, period)
       _period = period
@@ -102,53 +104,63 @@ object Contexts {
 
     /** The scope nesting level */
     private[this] var _mode: Mode = _
+    @scala.annotation.init
     protected def mode_=(mode: Mode): Unit = _mode = mode
     def mode: Mode = _mode
 
     /** The current owner symbol */
     private[this] var _owner: Symbol = _
+    @scala.annotation.init
     protected def owner_=(owner: Symbol): Unit = _owner = owner
     def owner: Symbol = _owner
 
     /** The current tree */
     private[this] var _tree: Tree[_ >: Untyped]= _
+    @scala.annotation.init
     protected def tree_=(tree: Tree[_ >: Untyped]): Unit = _tree = tree
     def tree: Tree[_ >: Untyped] = _tree
 
     /** The current scope */
     private[this] var _scope: Scope = _
+    @scala.annotation.init
     protected def scope_=(scope: Scope): Unit = _scope = scope
     def scope: Scope = _scope
 
     /** The current type comparer */
     private[this] var _typerState: TyperState = _
+    @scala.annotation.init
     protected def typerState_=(typerState: TyperState): Unit = _typerState = typerState
     def typerState: TyperState = _typerState
 
     /** The current type assigner or typer */
     private[this] var _typeAssigner: TypeAssigner = _
+    @scala.annotation.init
     protected def typeAssigner_=(typeAssigner: TypeAssigner): Unit = _typeAssigner = typeAssigner
     def typeAssigner: TypeAssigner = _typeAssigner
 
     /** The currently active import info */
     private[this] var _importInfo: ImportInfo = _
+    @scala.annotation.init
     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 = _
+    @scala.annotation.init
     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
+    @scala.annotation.init
     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 = _
+    @scala.annotation.init
     protected def typeComparer_=(typeComparer: TypeComparer): Unit = _typeComparer = typeComparer
     def typeComparer: TypeComparer = {
       if (_typeComparer.ctx ne this)
@@ -160,6 +172,7 @@ object Contexts {
      *  Typically used for attributes that are read and written only in special situations.
      */
     private[this] var _moreProperties: Map[Key[Any], Any] = _
+    @scala.annotation.init
     protected def moreProperties_=(moreProperties: Map[Key[Any], Any]): Unit = _moreProperties = moreProperties
     def moreProperties: Map[Key[Any], Any] = _moreProperties
 
@@ -172,6 +185,7 @@ object Contexts {
      *  slightly slower than a normal field access would be.
      */
     private var _store: Store = _
+    @scala.annotation.init
     protected def store_=(store: Store): Unit = _store = store
     def store: Store = _store
 
@@ -219,7 +233,7 @@ object Contexts {
             else
               outer.implicits
           if (implicitRefs.isEmpty) outerImplicits
-          else new ContextualImplicits(implicitRefs, outerImplicits)(this)
+          else new ContextualImplicits(implicitRefs, outerImplicits)(this: @unchecked)
         }
       implicitsCache
     }
@@ -544,7 +558,7 @@ object Contexts {
   /** A class defining the initial context with given context base
    *  and set of possible settings.
    */
-  private class InitialContext(val base: ContextBase, settingsGroup: SettingGroup) extends FreshContext {
+  private class InitialContext(val base: ContextBase @scala.annotation.cold, settingsGroup: SettingGroup) extends FreshContext {
     outer = NoContext
     period = InitialPeriod
     mode = Mode.None
@@ -554,14 +568,14 @@ object Contexts {
     typeAssigner = TypeAssigner
     moreProperties = Map.empty
     store = initialStore.updated(settingsStateLoc, settingsGroup.defaultState)
-    typeComparer = new TypeComparer(this)
+    typeComparer = new TypeComparer(this: @unchecked)
     searchHistory = new SearchHistory(0, Map())
     gadt = EmptyGADTMap
   }
 
   @sharable object NoContext extends Context {
     val base: ContextBase = null
-    override val implicits: ContextualImplicits = new ContextualImplicits(Nil, null)(this)
+    override val implicits: ContextualImplicits = new ContextualImplicits(Nil, null)(this: @unchecked)
   }
 
   /** A context base defines state and associated methods that exist once per
@@ -673,7 +687,7 @@ object Contexts {
     private[core] var phasesPlan: List[List[Phase]] = _
 
     /** Phases by id */
-    private[dotc] var phases: Array[Phase] = _
+    final private[dotc] var phases: Array[Phase] = _
 
     /** Phases with consecutive Transforms grouped into a single phase, Empty array if squashing is disabled */
     private[core] var squashedPhases: Array[Phase] = Array.empty[Phase]

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -806,6 +806,16 @@ class Definitions {
   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
+  lazy val IcyAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.icy")
+  def IcyAnnot(implicit ctx: Context): ClassSymbol = IcyAnnotType.symbol.asClass
+  lazy val ColdAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.cold")
+  def ColdAnnot(implicit ctx: Context): ClassSymbol = ColdAnnotType.symbol.asClass
+  lazy val WarmAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.warm")
+  def WarmAnnot(implicit ctx: Context): ClassSymbol = WarmAnnotType.symbol.asClass
+  lazy val InitAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.init")
+  def InitAnnot(implicit ctx: Context): ClassSymbol = InitAnnotType.symbol.asClass
+  lazy val CallAnnotType: TypeRef = ctx.requiredClassRef("scala.annotation.internal.Call")
+  def CallAnnot(implicit ctx: Context): ClassSymbol = CallAnnotType.symbol.asClass
 
   // convenient one-parameter method types
   def methOfAny(tp: Type): MethodType = MethodType(List(AnyType), tp)

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -751,6 +751,7 @@ object Denotations {
     private[this] var myValidFor: Period = Nowhere
 
     def validFor: Period = myValidFor
+    @scala.annotation.init
     def validFor_=(p: Period): Unit = {
       myValidFor = p
       symbol.invalidateDenotCache()

compiler/src/dotty/tools/dotc/core/NameKinds.scala

@@ -36,6 +36,7 @@ object NameKinds {
     type ThisInfo <: Info
 
     /** A simple info type; some subclasses of Kind define more refined versions */
+    @scala.annotation.cold
     class Info extends NameInfo { this: ThisInfo =>
       def kind: NameKind = self
       def mkString(underlying: TermName): String = self.mkString(underlying, this)
@@ -85,7 +86,7 @@ object NameKinds {
       case _ => None
     }
 
-    simpleNameKinds(tag) = this
+    simpleNameKinds(tag) = this: @unchecked
   }
 
   /** The kind of names that get formed by adding a prefix to an underlying name */
@@ -151,7 +152,7 @@ object NameKinds {
 
     def infoString: String = s"Qualified $separator"
 
-    qualifiedNameKinds(tag) = this
+    qualifiedNameKinds(tag) = this: @unchecked
   }
 
   /** An extractor for qualified names of an arbitrary kind */
@@ -188,7 +189,7 @@ object NameKinds {
       else -1
     }
 
-    numberedNameKinds(tag) = this
+    numberedNameKinds(tag) = this: @unchecked
   }
 
   /** An extractor for numbered names of arbitrary kind */
@@ -221,7 +222,7 @@ object NameKinds {
     def fresh(prefix: TypeName)(implicit ctx: Context): TypeName =
       fresh(prefix.toTermName).toTypeName
 
-    uniqueNameKinds(separator) = this
+    uniqueNameKinds(separator) = this: @unchecked
   }
 
   /** An extractor for unique names of arbitrary kind */

compiler/src/dotty/tools/dotc/core/Names.scala

@@ -651,7 +651,7 @@ object Names {
   /** Create a type name from a string, without encoding operators */
   def typeName(s: String): TypeName = typeName(s.toCharArray, 0, s.length)
 
-  table(0) = new SimpleName(-1, 0, null)
+  table(0) = new SimpleName(-1, 0, null): @unchecked
 
   /** The term name represented by the empty string */
   val EmptyTermName: TermName = table(0)