Merge branch 'main' of https://github.com/rochala/dotty into illegal-access-extension-error-message

Author: rochala

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

@@ -52,6 +52,7 @@ trait BCodeIdiomatic {
     case "15" => asm.Opcodes.V15
     case "16" => asm.Opcodes.V16
     case "17" => asm.Opcodes.V17
+    case "18" => asm.Opcodes.V18
   }
 
   lazy val majorVersion: Int = (classfileVersion & 0xFF)

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -16,7 +16,7 @@ class ScalaSettings extends SettingGroup with AllScalaSettings
 object ScalaSettings:
   // Keep synchronized with `classfileVersion` in `BCodeIdiomatic`
   private val minTargetVersion = 8
-  private val maxTargetVersion = 17
+  private val maxTargetVersion = 18
 
   def supportedTargetVersions: List[String] =
     (minTargetVersion to maxTargetVersion).toList.map(_.toString)

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

@@ -1764,11 +1764,11 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
     case _ => false
 
   /** Does type `tp1` have a member with name `name` whose normalized type is a subtype of
-   *  the normalized type of the refinement `tp2`?
+   *  the normalized type of the refinement of `tp2`?
    *  Normalization is as follows: If `tp2` contains a skolem to its refinement type,
    *  rebase both itself and the member info of `tp` on a freshly created skolem type.
    */
-  protected def hasMatchingMember(name: Name, tp1: Type, tp2: RefinedType): Boolean =
+  def hasMatchingMember(name: Name, tp1: Type, tp2: RefinedType): Boolean =
     trace(i"hasMatchingMember($tp1 . $name :? ${tp2.refinedInfo}), mbr: ${tp1.member(name).info}", subtyping) {
 
       def qualifies(m: SingleDenotation): Boolean =
@@ -2750,6 +2750,9 @@ object TypeComparer {
   def matchesType(tp1: Type, tp2: Type, relaxed: Boolean)(using Context): Boolean =
     comparing(_.matchesType(tp1, tp2, relaxed))
 
+  def hasMatchingMember(name: Name, tp1: Type, tp2: RefinedType)(using Context): Boolean =
+    comparing(_.hasMatchingMember(name, tp1, tp2))
+
   def matchingMethodParams(tp1: MethodType, tp2: MethodType)(using Context): Boolean =
     comparing(_.matchingMethodParams(tp1, tp2))
 

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -556,9 +556,9 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case TypeBoundsTree(lo, hi, alias) =>
         if (lo eq hi) && alias.isEmpty then optText(lo)(" = " ~ _)
         else optText(lo)(" >: " ~ _) ~ optText(hi)(" <: " ~ _) ~ optText(alias)(" = " ~ _)
-      case Bind(name, body) =>
+      case bind @ Bind(name, body) =>
         keywordText("given ").provided(tree.symbol.isOneOf(GivenOrImplicit) && !homogenizedView) ~ // Used for scala.quoted.Type in quote patterns (not pickled)
-        changePrec(InfixPrec) { toText(name) ~ " @ " ~ toText(body) }
+        changePrec(InfixPrec) { nameIdText(bind) ~ " @ " ~ toText(body) }
       case Alternative(trees) =>
         changePrec(OrPrec) { toText(trees, " | ") }
       case UnApply(fun, implicits, patterns) =>

compiler/src/dotty/tools/dotc/transform/Dependencies.scala

@@ -179,6 +179,18 @@ abstract class Dependencies(root: ast.tpd.Tree, @constructorOnly rootContext: Co
         if enclClass.isContainedIn(thisClass) then thisClass
         else enclClass) // unknown this reference, play it safe and assume the narrowest possible owner
 
+    def setLogicOwner(local: Symbol) =
+      val encClass = local.owner.enclosingClass
+      val preferEncClass =
+        encClass.isStatic
+          // non-static classes can capture owners, so should be avoided
+        && (encClass.isProperlyContainedIn(local.topLevelClass)
+             // can be false for symbols which are defined in some weird combination of supercalls.
+            || encClass.is(ModuleClass, butNot = Package)
+                // needed to not cause deadlocks in classloader. see t5375.scala
+            )
+      logicOwner(sym) = if preferEncClass then encClass else local.enclosingPackageClass 
+
     tree match
       case tree: Ident =>
         if isLocal(sym) then
@@ -194,7 +206,7 @@ abstract class Dependencies(root: ast.tpd.Tree, @constructorOnly rootContext: Co
       case tree: This =>
         narrowTo(tree.symbol.asClass)
       case tree: MemberDef if isExpr(sym) && sym.owner.isTerm =>
-        logicOwner(sym) = sym.enclosingPackageClass
+        setLogicOwner(sym)
           // this will make methods in supercall constructors of top-level classes owned
           // by the enclosing package, which means they will be static.
           // On the other hand, all other methods will be indirectly owned by their
@@ -205,8 +217,8 @@ abstract class Dependencies(root: ast.tpd.Tree, @constructorOnly rootContext: Co
         // the class itself. This is done so that the constructor inherits
         // the free variables of the class.
         symSet(called, sym) += sym.owner
-      case tree: TypeDef =>
-        if sym.owner.isTerm then logicOwner(sym) = sym.topLevelClass.owner
+      case tree: TypeDef if sym.owner.isTerm =>
+        setLogicOwner(sym)
       case _ =>
   end process
 

compiler/src/dotty/tools/dotc/transform/LambdaLift.scala

@@ -94,20 +94,7 @@ object LambdaLift:
     private def liftLocals()(using Context): Unit = {
       for ((local, lOwner) <- deps.logicalOwner) {
         val (newOwner, maybeStatic) =
-          if (lOwner is Package) {
-            val encClass = local.enclosingClass
-            val topClass = local.topLevelClass
-            val preferEncClass =
-              encClass.isStatic &&
-                // non-static classes can capture owners, so should be avoided
-              (encClass.isProperlyContainedIn(topClass) ||
-                // can be false for symbols which are defined in some weird combination of supercalls.
-               encClass.is(ModuleClass, butNot = Package)
-                // needed to not cause deadlocks in classloader. see t5375.scala
-              )
-            if (preferEncClass) (encClass, EmptyFlags)
-            else (topClass, JavaStatic)
-          }
+          if lOwner is Package then (local.topLevelClass, JavaStatic)
           else (lOwner, EmptyFlags)
         // Drop Module because class is no longer a singleton in the lifted context.
         var initFlags = local.flags &~ Module | Private | Lifted | maybeStatic

compiler/src/dotty/tools/dotc/transform/MegaPhase.scala

@@ -418,12 +418,16 @@ class MegaPhase(val miniPhases: Array[MiniPhase]) extends Phase {
         }
     }
 
-    if (tree.source != ctx.source && tree.source.exists)
-      transformTree(tree, start)(using ctx.withSource(tree.source))
-    else if (tree.isInstanceOf[NameTree])
-      transformNamed(tree, start, ctx)
-    else
-      transformUnnamed(tree, start, ctx)
+    // try
+      if (tree.source != ctx.source && tree.source.exists)
+        transformTree(tree, start)(using ctx.withSource(tree.source))
+      else if (tree.isInstanceOf[NameTree])
+        transformNamed(tree, start, ctx)
+      else
+        transformUnnamed(tree, start, ctx)
+    // catch case ex: AssertionError =>
+    //  println(i"error while transforming $tree")
+    //  throw ex
   }
 
   def transformSpecificTree[T <: Tree](tree: T, start: Int)(using Context): T =

compiler/src/dotty/tools/dotc/transform/TypeTestsCasts.scala

@@ -150,7 +150,7 @@ object TypeTestsCasts {
       case AndType(tp1, tp2)    => recur(X, tp1) && recur(X, tp2)
       case OrType(tp1, tp2)     => recur(X, tp1) && recur(X, tp2)
       case AnnotatedType(t, _)  => recur(X, t)
-      case _: RefinedType       => false
+      case tp2: RefinedType     => recur(X, tp2.parent) && TypeComparer.hasMatchingMember(tp2.refinedName, X, tp2)
       case _                    => true
     })
 

compiler/src/dotty/tools/dotc/typer/Applications.scala

@@ -1876,7 +1876,7 @@ trait Applications extends Compatibility {
      *       formal parameter that is a unary function.
      */
     def normArg(alts: List[TermRef], arg: untpd.Tree, idx: Int): untpd.Tree = arg match
-      case Block(Nil, expr) => normArg(alts, expr, idx)
+      case Block(Nil, expr) if !expr.isEmpty => normArg(alts, expr, idx)
       case untpd.Function(args: List[untpd.ValDef] @unchecked, body) =>
 
         // If ref refers to a method whose parameter at index `idx` is a function type,

compiler/src/dotty/tools/dotc/typer/ErrorReporting.scala

@@ -306,15 +306,13 @@ class ImplicitSearchError(
 
   private def location(preposition: String) = if (where.isEmpty) "" else s" $preposition $where"
 
-  private def defaultAmbiguousImplicitMsg(ambi: AmbiguousImplicits) = {
-    formatMsg(s"ambiguous implicit arguments: ${ambi.explanation}${location("of")}")(
-      s"ambiguous implicit arguments of type ${pt.show} found${location("for")}"
+  private def defaultAmbiguousImplicitMsg(ambi: AmbiguousImplicits) =
+    formatMsg(s"ambiguous given instances: ${ambi.explanation}${location("of")}")(
+      s"ambiguous given instances of type ${pt.show} found${location("for")}"
     )
-  }
 
-  private def defaultImplicitNotFoundMessage = {
-    ex"no implicit argument of type $pt was found${location("for")}"
-  }
+  private def defaultImplicitNotFoundMessage =
+    ex"no given instance of type $pt was found${location("for")}"
 
   /** Construct a custom error message given an ambiguous implicit
    *  candidate `alt` and a user defined message `raw`.