Merge branch 'main' into 23908

Author: HarrisL2

compiler/src/dotty/tools/MainGenericCompiler.scala

@@ -85,7 +85,7 @@ case class CompileSettings(
 
 object MainGenericCompiler {
 
-  val classpathSeparator = File.pathSeparator
+  val classpathSeparator: String = File.pathSeparator
 
   @sharable val javaOption = raw"""-J(.*)""".r
   @sharable val javaPropOption = raw"""-D(.+?)=(.?)""".r

compiler/src/dotty/tools/MainGenericRunner.scala

@@ -96,7 +96,7 @@ case class Settings(
 
 object MainGenericRunner {
 
-  val classpathSeparator = File.pathSeparator
+  val classpathSeparator: String = File.pathSeparator
 
   def processClasspath(cp: String, tail: List[String]): (List[String], List[String]) =
     val cpEntries = cp.split(classpathSeparator).toList

compiler/src/dotty/tools/backend/jvm/CodeGen.scala

@@ -152,7 +152,7 @@ class CodeGen(val int: DottyBackendInterface, val primitives: DottyPrimitives)(
     new interfaces.AbstractFile {
       override def name = absfile.name
       override def path = absfile.path
-      override def jfile = Optional.ofNullable(absfile.file)
+      override def jfile: Optional[java.io.File] = Optional.ofNullable(absfile.file)
     }
 
   private def genClass(cd: TypeDef, unit: CompilationUnit): ClassNode = {

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -85,6 +85,8 @@ final class JSDefinitions()(using Context) {
   def JSGlobalScopeAnnot(using Context) = JSGlobalScopeAnnotType.symbol.asClass
   @threadUnsafe lazy val JSNameAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSName")
   def JSNameAnnot(using Context) = JSNameAnnotType.symbol.asClass
+  @threadUnsafe lazy val JSOperatorAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSOperator")
+  def JSOperatorAnnot(using Context) = JSOperatorAnnotType.symbol.asClass
   @threadUnsafe lazy val JSFullNameAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSFullName")
   def JSFullNameAnnot(using Context) = JSFullNameAnnotType.symbol.asClass
   @threadUnsafe lazy val JSBracketAccessAnnotType: TypeRef = requiredClassRef("scala.scalajs.js.annotation.JSBracketAccess")
@@ -213,6 +215,14 @@ final class JSDefinitions()(using Context) {
   @threadUnsafe lazy val WrappedArrayType: TypeRef = requiredClassRef("scala.scalajs.js.WrappedArray")
   def WrappedArrayClass(using Context) = WrappedArrayType.symbol.asClass
 
+  @threadUnsafe lazy val LinkingInfoModuleRef = requiredModuleRef("scala.scalajs.LinkingInfo")
+  def LinkingInfoModule(using Context) = LinkingInfoModuleRef.symbol
+    @threadUnsafe lazy val LinkingInfo_linkTimeIfR = LinkingInfoModule.requiredMethodRef("linkTimeIf")
+    def LinkingInfo_linkTimeIf(using Context) = LinkingInfo_linkTimeIfR.symbol
+
+  @threadUnsafe lazy val LinkTimePropertyAnnotType: TypeRef = requiredClassRef("scala.scalajs.annotation.linkTimeProperty")
+  def LinkTimePropertyAnnot(using Context) = LinkTimePropertyAnnotType.symbol.asClass
+
   @threadUnsafe lazy val ScalaRunTime_isArrayR = defn.ScalaRuntimeModule.requiredMethodRef("isArray", List(???, ???))
   def ScalaRunTime_isArray(using Context): Symbol = ScalaRunTime_isArrayR.symbol
 

compiler/src/dotty/tools/backend/sjs/JSDefinitions.scala

@@ -47,8 +47,10 @@ object JSPrimitives {
   inline val UNWRAP_FROM_THROWABLE = WRAP_AS_THROWABLE + 1 // js.special.unwrapFromThrowable
   inline val DEBUGGER = UNWRAP_FROM_THROWABLE + 1          // js.special.debugger
 
-  inline val THROW = DEBUGGER + 1  // <special-ops>.throw
-  inline val NEW_ARRAY = THROW + 1 // scala.runtime.Arrays.newArray
+  inline val LINKTIME_IF = DEBUGGER + 1 // LinkingInfo.linkTimeIf
+
+  inline val THROW = LINKTIME_IF + 1 // <special-ops>.throw
+  inline val NEW_ARRAY = THROW + 1   // scala.runtime.Arrays.newArray
 
   inline val UNION_FROM = NEW_ARRAY + 1                   // js.|.from
   inline val UNION_FROM_TYPE_CONSTRUCTOR = UNION_FROM + 1 // js.|.fromTypeConstructor
@@ -135,6 +137,8 @@ class JSPrimitives(ictx: Context) extends DottyPrimitives(ictx) {
     addPrimitive(jsdefn.Special_unwrapFromThrowable, UNWRAP_FROM_THROWABLE)
     addPrimitive(jsdefn.Special_debugger, DEBUGGER)
 
+    addPrimitive(jsdefn.LinkingInfo_linkTimeIf, LINKTIME_IF)
+
     addPrimitive(defn.throwMethod, THROW)
     addPrimitive(defn.newArrayMethod, NEW_ARRAY)
 

compiler/src/dotty/tools/backend/sjs/JSPrimitives.scala

@@ -171,7 +171,7 @@ class Compiler {
     val rctx =
       if ctx.settings.Xsemanticdb.value then
         ctx.addMode(Mode.ReadPositions)
-      else if ctx.settings.YcheckInitGlobal.value then
+      else if ctx.settings.YsafeInitGlobal.value then
         ctx.addMode(Mode.ReadPositions)
       else
         ctx

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

@@ -1347,7 +1347,7 @@ object desugar {
       )).withSpan(tree.span)
   end makePolyFunctionType
 
-  /** Invent a name for an anonympus given of type or template `impl`. */
+  /** Invent a name for an anonymous given of type or template `impl`. */
   def inventGivenName(impl: Tree)(using Context): SimpleName =
     val str = impl match
       case impl: Template =>
@@ -2136,18 +2136,19 @@ object desugar {
        *  that refers to the bound variable for the pattern. Wildcard Binds are
        *  also replaced by Binds with fresh names.
        */
-      def makeIdPat(pat: Tree): (Tree, Ident) = pat match {
-        case bind @ Bind(name, pat1) =>
-          if name == nme.WILDCARD then
-            val name = UniqueName.fresh()
-            (cpy.Bind(pat)(name, pat1).withMods(bind.mods), Ident(name))
-          else (pat, Ident(name))
+      def makeIdPat(pat: Tree): (Tree, Ident) = pat match
+        case pat @ Bind(nme.WILDCARD, body) =>
+          val name =
+            body match
+            case Typed(Ident(nme.WILDCARD), tpt) if pat.mods.is(Given) => inventGivenName(tpt)
+            case _ => UniqueName.fresh()
+          (cpy.Bind(pat)(name, body).withMods(pat.mods), Ident(name))
+        case Bind(name, _) => (pat, Ident(name))
         case id: Ident if isVarPattern(id) && id.name != nme.WILDCARD => (id, id)
         case Typed(id: Ident, _) if isVarPattern(id) && id.name != nme.WILDCARD => (pat, id)
         case _ =>
           val name = UniqueName.fresh()
           (Bind(name, pat), Ident(name))
-      }
 
       /** Make a pattern filter:
        *    rhs.withFilter { case pat => true case _ => false }

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

@@ -898,7 +898,9 @@ object Capabilities:
         case t @ AnnotatedType(parent, ann) =>
           val parent1 = this(parent)
           if ann.symbol.isRetains && ann.tree.toCaptureSet.containsCap then
-            this(CapturingType(parent1, ann.tree.toCaptureSet))
+            // Applying `this` can cause infinite recursion in some cases during printing.
+            // scalac -Xprint:all tests/pos/i23885/S_1.scala tests/pos/i23885/S_2.scala
+            mapOver(CapturingType(parent1, ann.tree.toCaptureSet))
           else
             t.derivedAnnotatedType(parent1, ann)
         case defn.RefinedFunctionOf(_) =>

compiler/src/dotty/tools/dotc/cc/Capability.scala

@@ -14,6 +14,7 @@ import Annotations.Annotation
 import CaptureSet.VarState
 import Capabilities.*
 import StdNames.nme
+import config.Feature
 
 /** Attachment key for capturing type trees */
 private val Captures: Key[CaptureSet] = Key()
@@ -634,13 +635,18 @@ extension (tp: AnnotatedType)
     case ann: CaptureAnnotation => ann.boxed
     case _ => false
 
-/** Drop retains annotations in the type. */
+/** Drop retains annotations in the inferred type if CC is not enabled
+ *  or transform them into RetainingTypes if CC is enabled.
+ */
 class CleanupRetains(using Context) extends TypeMap:
-  def apply(tp: Type): Type =
-    tp match
-      case AnnotatedType(tp, annot) if annot.symbol == defn.RetainsAnnot || annot.symbol == defn.RetainsByNameAnnot =>
-        RetainingType(tp, defn.NothingType, byName = annot.symbol == defn.RetainsByNameAnnot)
-      case _ => mapOver(tp)
+  def apply(tp: Type): Type = tp match
+    case AnnotatedType(parent, annot) if annot.symbol.isRetainsLike =>
+      if Feature.ccEnabled then
+        if annot.symbol == defn.RetainsAnnot || annot.symbol == defn.RetainsByNameAnnot then
+          RetainingType(parent, defn.NothingType, byName = annot.symbol == defn.RetainsByNameAnnot)
+        else mapOver(tp)
+      else apply(parent)
+    case _ => mapOver(tp)
 
 /** A base class for extractors that match annotated types with a specific
  *  Capability annotation.