Check single threaded access to Contexts, Scopes, Denotation, HashSets

Author: DarkDimius

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

@@ -623,8 +623,10 @@ object Contexts {
 
     /** Check that we are on the same thread as before */
     def checkSingleThreaded() =
+    synchronized {
       if (thread == null) thread = Thread.currentThread()
       else assert(thread == Thread.currentThread(), "illegal multithreaded access to ContextBase")
+    }
   }
 
   object Context {

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

@@ -174,6 +174,16 @@ object Scopes {
      */
     private var hashTable: Array[ScopeEntry] = null
 
+    private var thread: Thread = null
+
+    private def checkSingleThreaded = {
+      this.synchronized {
+        if (thread == null)
+          thread = Thread.currentThread()
+        else assert(thread == Thread.currentThread())
+      }
+    }
+
     /** a cache for all elements, to be used by symbol iterator.
      */
     private var elemsCache: List[Symbol] = null
@@ -197,6 +207,7 @@ object Scopes {
 
     /** create and enter a scope entry with given name and symbol */
     protected def newScopeEntry(name: Name, sym: Symbol)(implicit ctx: Context): ScopeEntry = {
+      checkSingleThreaded
       ensureCapacity(if (hashTable ne null) hashTable.length else MinHash)
       val e = new ScopeEntry(name, sym, this)
       e.prev = lastEntry
@@ -212,6 +223,7 @@ object Scopes {
       newScopeEntry(sym.name, sym)
 
     private def enterInHash(e: ScopeEntry)(implicit ctx: Context): Unit = {
+      checkSingleThreaded
       val idx = e.name.hashCode & (hashTable.length - 1)
       e.tail = hashTable(idx)
       assert(e.tail != e)
@@ -247,6 +259,7 @@ object Scopes {
 
     private def enterAllInHash(e: ScopeEntry, n: Int = 0)(implicit ctx: Context): Unit = {
       if (e ne null) {
+        checkSingleThreaded
         if (n < MaxRecursions) {
           enterAllInHash(e.prev, n + 1)
           enterInHash(e)
@@ -264,6 +277,7 @@ object Scopes {
 
     /** Remove entry from this scope (which is required to be present) */
     final def unlink(e: ScopeEntry)(implicit ctx: Context): Unit = {
+      checkSingleThreaded
       if (lastEntry == e) {
         lastEntry = e.prev
       } else {
@@ -298,6 +312,7 @@ object Scopes {
      *  @pre `prev` and `replacement` have the same name.
      */
     final def replace(prev: Symbol, replacement: Symbol)(implicit ctx: Context): Unit = {
+      checkSingleThreaded
       require(prev.name == replacement.name)
       var e = lookupEntry(prev.name)
       while (e ne null) {

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

@@ -1400,8 +1400,18 @@ object SymDenotations {
 
     private[this] var myMemberCache: LRUCache[Name, PreDenotation] = null
     private[this] var myMemberCachePeriod: Period = Nowhere
+    private var thread: Thread = null
+
+    private def checkSingleThreaded = {
+      this.synchronized {
+        if (thread == null)
+          thread = Thread.currentThread()
+        else assert(thread == Thread.currentThread())
+      }
+    }
 
     private def memberCache(implicit ctx: Context): LRUCache[Name, PreDenotation] = {
+      checkSingleThreaded
       if (myMemberCachePeriod != ctx.period) {
         myMemberCache = new LRUCache
         myMemberCachePeriod = ctx.period
@@ -1416,6 +1426,7 @@ object SymDenotations {
      *                 If this is EmptyScope, the scope is `decls`.
      */
     def enter(sym: Symbol, scope: Scope = EmptyScope)(implicit ctx: Context): Unit = {
+      checkSingleThreaded
       val mscope = scope match {
         case scope: MutableScope =>
           // if enter gets a scope as an argument,

src/dotty/tools/dotc/util/HashSet.scala

@@ -100,9 +100,11 @@ class HashSet[T >: Null <: AnyRef](initialCapacity: Int, loadFactor: Float = 0.2
   }
 
   private def checkTread: Unit = {
-    if (thread == null)
-      thread = Thread.currentThread()
-    else assert(thread == Thread.currentThread())
+    synchronized {
+      if (thread == null)
+        thread = Thread.currentThread()
+      else assert(thread == Thread.currentThread())
+    }
   }
 
   /** Privileged access: Find first entry with given hashcode */

src/dotty/tools/dotc/util/LRUCache.scala

@@ -51,6 +51,16 @@ class LRUCache[Key >: Null <: AnyRef : ClassTag, Value >: Null: ClassTag] {
     lookupNext(last, first, next)
   }
 
+  private var thread: Thread = null
+
+  private def checkSingleThreaded = {
+    this.synchronized {
+      if (thread == null)
+        thread = Thread.currentThread()
+      else assert(thread == Thread.currentThread())
+    }
+  }
+
   /** Enter key/value in cache at position `last`.
    *  As a side effect, sets `last` to `lastButOne`.
    *  If `lastButOne` was set by a preceding unsuccessful `lookup`
@@ -59,6 +69,7 @@ class LRUCache[Key >: Null <: AnyRef : ClassTag, Value >: Null: ClassTag] {
    *  is inserted at a random position in the queue.
    */
   def enter(key: Key, value: Value): Unit = {
+    checkSingleThreaded
     keys(last) = key
     values(last) = value
     last = lastButOne
@@ -67,11 +78,13 @@ class LRUCache[Key >: Null <: AnyRef : ClassTag, Value >: Null: ClassTag] {
   /** Invalidate key. The invalidated element becomes
    *  the last in the queue.
    */
-  def invalidate(key: Key): Unit =
+  def invalidate(key: Key): Unit = {
+    checkSingleThreaded
     if (lookup(key) != null) {
       keys(first) = null
       last = first
     }
+  }
 
   def indices: Iterator[Int] = Iterator.iterate(first)(next.apply)