Update compiler/src/dotty/tools/dotc/core/NameOps.scala

Co-authored-by: Jamie Thompson <bishbashboshjt@gmail.com>

Author: tudorv91

.jvmopts

@@ -1,4 +1,6 @@
 -Xss1m
 -Xms512m
--Xmx1200m
+-Xmx4096m
 -XX:MaxInlineLevel=35
+-XX:ReservedCodeCacheSize=512m
+-XX:MaxMetaspaceSize=1024m

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

@@ -147,26 +147,33 @@ object desugar {
 
 // ----- Desugar methods -------------------------------------------------
 
+  /** Setter generation is needed for:
+   *    - non-private class members
+   *    - all trait members
+   *    - all package object members
+   */
+  def isSetterNeeded(valDef: ValDef)(using Context): Boolean = {
+    val mods = valDef.mods
+    mods.is(Mutable)
+      && ctx.owner.isClass
+      && (!mods.is(Private) || ctx.owner.is(Trait) || ctx.owner.isPackageObject)
+  }
+
   /**   var x: Int = expr
    *  ==>
    *    def x: Int = expr
    *    def x_=($1: <TypeTree()>): Unit = ()
    *
-   *  Generate the setter only for
-   *    - non-private class members
-   *    - all trait members
-   *    - all package object members
+   *  Generate setter where needed
    */
   def valDef(vdef0: ValDef)(using Context): Tree = {
     val vdef @ ValDef(_, tpt, rhs) = vdef0
     val mods = vdef.mods
-    val setterNeeded =
-      mods.is(Mutable)
-      && ctx.owner.isClass
-      && (!mods.is(Private) || ctx.owner.is(Trait) || ctx.owner.isPackageObject)
-    val valName = normalizeName(vdef, tpt).asTermName
 
-    if (setterNeeded) {
+    val setterForValNeeded = isSetterNeeded(vdef)
+    val valName = normalizeName(vdef, tpt, setterForValNeeded).asTermName
+
+    if (setterForValNeeded) {
       // TODO: copy of vdef as getter needed?
       // val getter = ValDef(mods, name, tpt, rhs) withPos vdef.pos?
       // right now vdef maps via expandedTree to a thicket which concerns itself.
@@ -632,7 +639,7 @@ object desugar {
     val (clsDerived, companionDerived) =
       if (mods.is(Module)) (impl.derived, Nil) else (Nil, impl.derived)
 
-    // The thicket which is the desugared version of the companion object
+    // The thicket which is the dessetterNeededugared version of the companion object
     //     synthetic object C extends parentTpt derives class-derived { defs }
     def companionDefs(parentTpt: Tree, defs: List[Tree]) = {
       val mdefs = moduleDef(
@@ -926,7 +933,7 @@ object desugar {
    *      method is an extension method.
    *   3. If the name is missing (this can be the case for instance definitions), invent one instead.
    */
-  def normalizeName(mdef: MemberDef, impl: Tree)(using Context): Name = {
+  def normalizeName(mdef: MemberDef, impl: Tree, setterForValNeeded: Boolean = false)(using Context): Name = {
     var name = mdef.name
     if (name.isEmpty) name = name.likeSpaced(inventGivenOrExtensionName(impl))
     def errPos = mdef.source.atSpan(mdef.nameSpan)
@@ -936,7 +943,7 @@ object desugar {
       name = name.errorName
     }
     mdef match {
-      case vdef: ValDef if name.isExtension && vdef.mods.is(Mutable) =>
+      case vdef: ValDef if setterForValNeeded && name.isExtension  =>
         report.error(em"illegal setter name: `extension_=`", errPos)
       case memDef if name.isExtensionName && !mdef.mods.is(ExtensionMethod) =>
         report.error(em"illegal name: $name may not start with `extension_`", errPos)

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

@@ -134,7 +134,10 @@ object NameOps {
     }
 
     /** Does the name match `extension`? */
-    def isExtension: Boolean = name.toString == "extension"
+    def isExtension: Boolean = name match
+      case name: SimpleName =>
+        name.length == "extension".length && name.startsWith("extension")
+      case _ => false
 
     /** Does this name start with `extension_`? */
     def isExtensionName: Boolean = name match

tests/neg/illegal-extension.check

@@ -7,10 +7,14 @@
   |      ^^^^^^^^^^^^^
   |      illegal name: extension_val may not start with `extension_`
 -- Error: tests/neg/illegal-extension.scala:5:14 -----------------------------------------------------------------------
-5 |  private var extension = Nil // error: not allowed because it matches `extension`
+5 |  private var extension = Nil // error: illegal setter name: `extension_=`
   |              ^^^^^^^^^
-  |              illegal variable name: `extension`
--- Error: tests/neg/illegal-extension.scala:8:23 -----------------------------------------------------------------------
-8 |extension (x: Any) def extension_foo: String = "foo" // error: illegal name: extension_foo may not start with `extension_`
-  |                       ^^^^^^^^^^^^^
-  |                       illegal name: extension_foo may not start with `extension_`
+  |              illegal setter name: `extension_=`
+-- Error: tests/neg/illegal-extension.scala:16:23 ----------------------------------------------------------------------
+16 |extension (x: Any) def extension_foo: String = "foo" // error: illegal name: extension_foo may not start with `extension_`
+   |                       ^^^^^^^^^^^^^
+   |                       illegal name: extension_foo may not start with `extension_`
+-- Error: tests/neg/illegal-extension.scala:9:6 ------------------------------------------------------------------------
+9 |  var extension = 1337 // error: illegal setter name: `extension_=`
+  |      ^^^^^^^^^
+  |      illegal setter name: `extension_=`

tests/neg/illegal-extension.scala

@@ -2,8 +2,19 @@ trait A {
   def extension_n: String = "illegal method" // error: illegal name: extension_n may not start with `extension_`
   type extension_type = Int // allowed because it's a type alias
   val extension_val = 23 // error: illegal name: extension_val may not start with `extension_`
-  private var extension = Nil // error: not allowed because it matches `extension`
+  private var extension = Nil // error: illegal setter name: `extension_=`
+}
+
+class B {
+  var extension = 1337 // error: illegal setter name: `extension_=`
+}
+
+class C {
+  private var extension = "OK" // allowed because it does not require a setter
 }
 
 extension (x: Any) def extension_foo: String = "foo" // error: illegal name: extension_foo may not start with `extension_`
-extension (some: Any) def valid_extension_name: String = "bar"
+extension (some: Any) def valid_extension_name: String = {
+  var extension = "foo" // `extension` name allowed because it doesn't require a setter
+  s"$extension bar"
+}