Warn when calling synchronized on Predef or on synthetic file objects

[mbovel]

Consider the following code in sync.scala:

package myPackage:
	def test1 = synchronized { println("1 starting"); Thread.sleep(2000); println("Ok t1 finished.") }
	def test2 = this.synchronized { println("2 starting"); Thread.sleep(2000); println("Ok t2 finished"); }

object MyObject:
	def test3 = synchronized { println("3 starting"); Thread.sleep(2000); println("Ok t3 finished.") }
	def test4 = this.synchronized { println("4 starting"); Thread.sleep(2000); println("Ok t4 finished"); }

scala-cli compile -Xprint:typer -Yprint-debug sync.scala ouputs:

package <root>.this.myPackage {
    final lazy module val sync2$package: myPackage.this.sync2$package$ = 
      new myPackage.this.sync2$package$.<init>()
    final module class sync2$package$() extends Object.<init>() { 
      this: myPackage.this.sync2$package.type =>
      def test1: scala.this.Unit(inf) = 
        scala.this.Predef.synchronized[scala.this.Unit^(inf)](
          {
            scala.this.Predef.println("1 starting")
            java.this.lang.Thread.sleep(2000L)
            scala.this.Predef.println("Ok t1 finished.")
          }
        )
      def test2: scala.this.Unit(inf) = 
        this.synchronized[scala.this.Unit^(inf)](
          {
            scala.this.Predef.println("2 starting")
            java.this.lang.Thread.sleep(2000L)
            scala.this.Predef.println("Ok t2 finished")
          }
        )
    }
  }
  final lazy module val MyObject: <empty>.this.MyObject$ = 
    new <empty>.this.MyObject$.<init>()
  final module class MyObject$() extends Object.<init>() { 
    this: <empty>.this.MyObject.type =>
    def test3: scala.this.Unit(inf) = 
      MyObject$.this.synchronized[scala.this.Unit^(inf)](
        {
          scala.this.Predef.println("3 starting")
          java.this.lang.Thread.sleep(2000L)
          scala.this.Predef.println("Ok t3 finished.")
        }
      )
    def test4: scala.this.Unit(inf) = 
      this.synchronized[scala.this.Unit^(inf)](
        {
          scala.this.Predef.println("4 starting")
          java.this.lang.Thread.sleep(2000L)
          scala.this.Predef.println("Ok t4 finished")
        }
      )
  }

C.f., the first synchronized is desugared to Predef.synchronized. This sounds rather confusing.

We should probably issue a warning in this case, and also when calling this.synchronized from top-level functions.

More context in #7713 (comment).

[scala-center-bot]

This issue was picked for the Issue Spree No. 29 of 18 April 2023 which takes place in a week from now. @mbovel, @jan-pieter, @yawen-guan will be working on it. If you have any insight into the issue or guidance on how to fix it, please leave it here.

[mbovel]

I had to rebalance the issue spree teams due to some absences. In the end, we will not tackle this issue today. @jan-pieter, I re-assigned you to #12460.

[mbovel]

Related: #17284

[scala-center-bot]

This issue was picked for the Issue Spree No. 30 of 09 May 2023 which takes place in a week from now. @mbovel, @shivakg will be working on it. If you have any insight into the issue or guidance on how to fix it, please leave it here.

[mbovel]

Background

AnyRef

AnyRef is the base class for all objects in Scala, similarly to Object in Java. See this diagram from the “Unified Types” documentation page:

synchronized

synchronized is a method of AnyRef, see its documentation:

Normally, an un-qualified call to synchronize is de-sugared to this.synchronized.

So what does this corresponds to when we are in a top-level definition? For example:

def test1 = synchronized { println("1 starting"); Thread.sleep(2000); println("Ok t1 finished.") }

Well, in this case, synchronized corresponds to Predef. synchronized. This is what we see in the description of this issue:

      def test1: scala.this.Unit(inf) = 
        scala.this.Predef.synchronized[scala.this.Unit^(inf)](
          {
            scala.this.Predef.println("1 starting")
            java.this.lang.Thread.sleep(2000L)
            scala.this.Predef.println("Ok t1 finished.")
          }
        )

So, what is Predef?

Predef

Predef is an object containing methods and types than can be accessed without qualification; that's all the “built-in” stuff we can access directly. See the documentation:

For example, Predef contains the println method and common types like List or Map.

AnyRef methods on Predef

Like any object, Predef inherits from AnyRef methods.

The problem is that calling AnyRef-methods like synchronized, wait or toString directly when we are not in an object doesn't really make sense. In the case of synchronized, it means that the lock of the singleton Predef object—a global lock—will be used, which is likely not what the user wants.

To solve this, we want to add a warning when calling AnyRef-methods on Predef.

[mbovel]

Please ignore the 2 previous message from the Scala Center bot. Teams for the next spree can be found here: https://airtable.com/shrSni1OItSuErosU/tblLEWc2ISeGHPbsc. Sorry for the spam!