Revert "WIP on paralelization"

This reverts commit cb00827.

Author: DarkDimius

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

@@ -704,9 +704,8 @@ object Trees {
    *  The contained trees will be integrated when transformed with
    *  a `transform(List[Tree])` call.
    */
-  case class Thicket[-T >: Untyped](val treesList: List[Tree[T]])
+  case class Thicket[-T >: Untyped](trees: List[Tree[T]])
     extends Tree[T] with WithoutTypeOrPos[T] {
-    def trees = treesList
     type ThisTree[-T >: Untyped] = Thicket[T]
     override def isEmpty: Boolean = trees.isEmpty
     override def toList: List[Tree[T]] = flatten(trees)

src/dotty/tools/dotc/ast/tpd.scala

@@ -19,21 +19,6 @@ import scala.annotation.tailrec
 /** Some creators for typed trees */
 object tpd extends Trees.Instance[Type] with TypedTreeInfo {
 
-  class TypedAsync(val untypedTree: untpd.Tree, val outerTpe: Type, val ctx:Context) extends Thicket(Nil) {
-
-    var typedTree: tpd.Tree = null
-
-    override def trees = {
-      if (typedTree eq null) {
-        typedTree = ctx.typer.typedExpr(untypedTree, outerTpe)(ctx)
-      }
-      ctx.typerState.commit()(ctx)
-      List(typedTree)
-    }
-
-    override def toString: String = s"TypedAsync($untypedTree, $outerTpe)($typedTree)"
-  }
-
   private def ta(implicit ctx: Context) = ctx.typeAssigner
 
   def Modifiers(sym: Symbol)(implicit ctx: Context): Modifiers = Modifiers(

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

@@ -29,8 +29,6 @@ import config.{Settings, ScalaSettings, Platform, JavaPlatform}
 import language.implicitConversions
 import DenotTransformers.DenotTransformer
 
-import scala.collection.concurrent.TrieMap
-
 object Contexts {
 
   /** A context is passed basically everywhere in dotc.
@@ -510,29 +508,6 @@ object Contexts {
     /** The platform */
     val platform: Platform = new JavaPlatform
 
-    val executors = new java.util.concurrent.ForkJoinPool()
-
-    def addToWaitList(dependOn: Thread, monitor: Object): Boolean = {
-      val thisThread = Thread.currentThread()
-      def followAliases(cur: Thread): Thread = {
-        val nxt = waitList.getOrElse(cur, null)
-        if ((nxt ne null) && (nxt ne thisThread))
-          followAliases(nxt)
-        else
-          nxt
-      }
-      if (followAliases(dependOn) eq null) {
-        waitList.put(Thread.currentThread(), dependOn)
-        println(s"$thisThread waiting for $dependOn")
-        monitor.synchronized {
-          monitor.wait()
-        }
-        true
-      } else false
-    }
-
-    val waitList = new TrieMap[Thread, Thread]()
-
     /** The loader that loads the members of _root_ */
     def rootLoader(root: TermSymbol)(implicit ctx: Context): SymbolLoader = platform.rootLoader(root)
 

src/dotty/tools/dotc/core/SymDenotations.scala

@@ -2,8 +2,6 @@ package dotty.tools
 package dotc
 package core
 
-import java.util.concurrent.atomic.AtomicReference
-
 import Periods._, Contexts._, Symbols._, Denotations._, Names._, NameOps._, Annotations._
 import Types._, Flags._, Decorators._, DenotTransformers._, StdNames._, Scopes._
 import NameOps._
@@ -88,7 +86,6 @@ object SymDenotations {
     // ------ Getting and setting fields -----------------------------
 
     private[this] var myFlags: FlagSet = adaptFlags(initFlags)
-    private[this] val initializingThread: AtomicReference[Thread] = new AtomicReference[Thread](null)
     private[this] var myInfo: Type = initInfo
     private[this] var myPrivateWithin: Symbol = initPrivateWithin
     private[this] var myAnnotations: List[Annotation] = Nil
@@ -166,52 +163,27 @@ object SymDenotations {
     }
 
     private def completeFrom(completer: LazyType)(implicit ctx: Context): Unit = {
-
-      // if (myFlags is Touched) throw CyclicReference(this)
-      val touched = myFlags is Touched
+      if (completions ne noPrinter) {
+        completions.println(i"${"  " * indent}completing ${if (isType) "type" else "val"} $name")
+        indent += 1
+      }
+      indent += 1
+      if (myFlags is Touched) throw CyclicReference(this)
       myFlags |= Touched
-      val curThread = initializingThread.get()
-      if (curThread eq Thread.currentThread())
-        throw CyclicReference(this)
-      if ((curThread ne null)) {
-        val noCycle = ctx.addToWaitList(curThread, this)
-        if (!noCycle) {
-          println("yesCycle")
-          throw CyclicReference(this)
-        }
-        info
-      } else if (initializingThread.compareAndSet(null, Thread.currentThread())) {
 
+      // completions.println(s"completing ${this.debugString}")
+      try completer.complete(this)(ctx.withPhase(validFor.firstPhaseId))
+      catch {
+        case ex: CyclicReference =>
+          completions.println(s"error while completing ${this.debugString}")
+          throw ex
+      }
+      finally
         if (completions ne noPrinter) {
-          completions.println(i"${"  " * indent}completing ${if (isType) "type" else "val"} $name")
-          indent += 1
-        }
-        indent += 1
-
-        // completions.println(s"completing ${this.debugString}")
-        this.synchronized {
-          try {
-            completer.complete(this)(ctx.withPhase(validFor.firstPhaseId))
-          }
-          catch {
-            case ex: CyclicReference =>
-              completions.println(s"error while completing ${this.debugString}")
-              throw ex
-          }
-          finally {
-            if (completions ne noPrinter) {
-              indent -= 1
-              completions.println(i"${"  " * indent}completed $name in $owner")
-            }
-            val oldV = initializingThread.get()
-            assert(oldV == Thread.currentThread())
-            initializingThread.set(null)
-
-            this.notifyAll()
-          }
+          indent -= 1
+          completions.println(i"${"  " * indent}completed $name in $owner")
         }
-        // completions.println(s"completed ${this.debugString}")
-      } else info
+      // completions.println(s"completed ${this.debugString}")
     }
 
     protected[dotc] def info_=(tp: Type) = {
@@ -1642,20 +1614,18 @@ object SymDenotations {
       /*>|>*/ ctx.debugTraceIndented(s"$tp.baseTypeRef($this)") /*<|<*/ {
         tp match {
           case tp: CachedType =>
-            this.synchronized {
-              checkBasesUpToDate()
-              var basetp = baseTypeRefCache get tp
-              if (basetp == null) {
-                baseTypeRefCache.put(tp, NoPrefix)
-                basetp = computeBaseTypeRefOf(tp)
-                if (isCachable(tp)) baseTypeRefCache.put(tp, basetp)
-                else baseTypeRefCache.remove(tp)
-              } else if (basetp == NoPrefix) {
-                baseTypeRefCache.put(tp, null)
-                throw CyclicReference(this)
-              }
-              basetp
+            checkBasesUpToDate()
+            var basetp = baseTypeRefCache get tp
+            if (basetp == null) {
+              baseTypeRefCache.put(tp, NoPrefix)
+              basetp = computeBaseTypeRefOf(tp)
+              if (isCachable(tp)) baseTypeRefCache.put(tp, basetp)
+              else baseTypeRefCache.remove(tp)
+            } else if (basetp == NoPrefix) {
+              baseTypeRefCache.put(tp, null)
+              throw CyclicReference(this)
             }
+            basetp
           case _ =>
             computeBaseTypeRefOf(tp)
         }

src/dotty/tools/dotc/core/SymbolLoaders.scala

@@ -156,8 +156,7 @@ class SymbolLoaders {
       val pre = root.owner.thisType
       root.info = ClassInfo(pre, root.symbol.asClass, Nil, currentDecls, pre select sourceModule)
       if (!sourceModule.isCompleted)
-         sourceModule.completer.complete(sourceModule) // todo: am I sure that this gets executed only by a single thread?
-         //sourceModule.info
+        sourceModule.completer.complete(sourceModule)
       if (!root.isRoot) {
         for (classRep <- classpath.classes)
           if (!maybeModuleClass(classRep))

src/dotty/tools/dotc/core/Types.scala

@@ -3285,9 +3285,7 @@ object Types {
 
   class CyclicReference private (val denot: SymDenotation)
     extends TypeError(s"cyclic reference involving $denot") {
-    val thread = Thread.currentThread()
-    val stack = new Exception()
-    def show(implicit ctx: Context) = s"cyclic reference involving ${denot.show} in $thread. Stack: ${stack.getStackTrace.mkString("\n")}"
+    def show(implicit ctx: Context) = s"cyclic reference involving ${denot.show}"
   }
 
   object CyclicReference {

src/dotty/tools/dotc/core/unpickleScala2/Scala2Unpickler.scala

@@ -369,12 +369,10 @@ class Scala2Unpickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClas
   }
 
   protected def atReadPos[T](start: Int, op: () => T): T = {
-    this.synchronized {
-      val savedIndex = readIndex
-      readIndex = start
-      try op()
-      finally readIndex = savedIndex
-    }
+    val savedIndex = readIndex
+    readIndex = start
+    try op()
+    finally readIndex = savedIndex
   }
 
   /** Read a name */

src/dotty/tools/dotc/transform/PostTyper.scala

@@ -108,8 +108,6 @@ class PostTyper extends MacroTransform with IdentityDenotTransformer  { thisTran
     tree match {
       case tree: TypeTree =>
         tree
-      case tree: TypedAsync =>
-        tree.trees.head
       case AppliedTypeTree(tycon, args) =>
         val tparams = tycon.tpe.typeSymbol.typeParams
         val bounds = tparams.map(tparam =>

src/dotty/tools/dotc/typer/FrontEnd.scala

@@ -68,9 +68,7 @@ class FrontEnd extends Phase {
     unitContexts foreach (enterSyms(_))
     unitContexts foreach (typeCheck(_))
     record("totalTrees", ast.Trees.ntrees)
-    val res = unitContexts.map(_.compilationUnit).filterNot(discardAfterTyper)
-    ctx.executors.awaitQuiescence(1, java.util.concurrent.TimeUnit.DAYS)
-    res
+    unitContexts.map(_.compilationUnit).filterNot(discardAfterTyper)
   }
 
   override def run(implicit ctx: Context): Unit = {

src/dotty/tools/dotc/typer/Typer.scala

@@ -910,11 +910,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     assignType(cpy.ValDef(vdef)(name, tpt1, rhs1), sym)
   }
 
-
-
   def typedDefDef(ddef: untpd.DefDef, sym: Symbol)(implicit ctx: Context) = track("typedDefDef") {
     val DefDef(name, tparams, vparamss, tpt, _) = ddef
-
     completeAnnotations(ddef, sym)
     val tparams1 = tparams mapconserve (typed(_).asInstanceOf[TypeDef])
     // for secondary constructors we need to use that their type parameters
@@ -927,20 +924,8 @@ class Typer extends Namer with TypeAssigner with Applications with Implicits wit
     val vparamss1 = vparamss nestedMapconserve (typed(_).asInstanceOf[ValDef])
     if (sym is Implicit) checkImplicitParamsNotSingletons(vparamss1)
     val tpt1 = checkSimpleKinded(typedType(tpt))
-
-    val typedAhead = expanded(ddef.rhs).getAttachment(TypedAhead)
-
-    if (typedAhead.isDefined || ddef.rhs.isEmpty) {
-      val rhs1 = typedExpr(ddef.rhs, tpt1.tpe)
-
-      assignType(cpy.DefDef(ddef)(name, tparams1, vparamss1, tpt1, rhs1), sym)
-    } else {
-
-      val asyncTree = new tpd.TypedAsync(ddef.rhs, tpt1.tpe, ctx.fresh.setNewTyperState)
-      ctx.executors.execute(new Runnable{def run = asyncTree.trees})
-
-      assignType(cpy.DefDef(ddef)(name, tparams1, vparamss1, tpt1, asyncTree), sym)
-    }
+    val rhs1 = typedExpr(ddef.rhs, tpt1.tpe)
+    assignType(cpy.DefDef(ddef)(name, tparams1, vparamss1, tpt1, rhs1), sym)
     //todo: make sure dependent method types do not depend on implicits or by-name params
   }