Merge branch 'master' into 9795

Author: gagandeepkalra

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

@@ -1235,18 +1235,31 @@ object desugar {
       rhsOK(rhs)
   }
 
+  def checkOpaqueAlias(tree: MemberDef)(using Context): MemberDef =
+    def check(rhs: Tree): MemberDef = rhs match
+      case bounds: TypeBoundsTree if bounds.alias.isEmpty =>
+        report.error(i"opaque type must have a right-hand side", tree.srcPos)
+        tree.withMods(tree.mods.withoutFlags(Opaque))
+      case LambdaTypeTree(_, body) => check(body)
+      case _ => tree
+    if !tree.mods.is(Opaque) then tree
+    else tree match
+      case TypeDef(_, rhs) => check(rhs)
+      case _ => tree
+
   /** Check that modifiers are legal for the definition `tree`.
    *  Right now, we only check for `opaque`. TODO: Move other modifier checks here.
    */
   def checkModifiers(tree: Tree)(using Context): Tree = tree match {
     case tree: MemberDef =>
       var tested: MemberDef = tree
-      def checkApplicable(flag: Flag, test: MemberDefTest): Unit =
+      def checkApplicable(flag: Flag, test: MemberDefTest): MemberDef =
         if (tested.mods.is(flag) && !test.applyOrElse(tree, (md: MemberDef) => false)) {
           report.error(ModifierNotAllowedForDefinition(flag), tree.srcPos)
-          tested = tested.withMods(tested.mods.withoutFlags(flag))
-        }
-      checkApplicable(Opaque, legalOpaque)
+           tested.withMods(tested.mods.withoutFlags(flag))
+        } else tested
+      tested = checkOpaqueAlias(tested)
+      tested = checkApplicable(Opaque, legalOpaque)
       tested
     case _ =>
       tree

compiler/src/dotty/tools/dotc/interactive/Completion.scala

@@ -12,11 +12,11 @@ import dotty.tools.dotc.core.Names.{Name, TermName}
 import dotty.tools.dotc.core.NameKinds.SimpleNameKind
 import dotty.tools.dotc.core.NameOps._
 import dotty.tools.dotc.core.Scopes._
-import dotty.tools.dotc.core.Symbols.{Symbol, defn}
+import dotty.tools.dotc.core.Symbols.{NoSymbol, Symbol, defn, newSymbol}
 import dotty.tools.dotc.core.StdNames.nme
 import dotty.tools.dotc.core.SymDenotations.SymDenotation
 import dotty.tools.dotc.core.TypeError
-import dotty.tools.dotc.core.Types.{AppliedType, ExprType, MethodOrPoly, NameFilter, NoType, TermRef, Type}
+import dotty.tools.dotc.core.Types.{AppliedType, ExprType, MethodOrPoly, NameFilter, NoType, RefinedType, TermRef, Type, TypeProxy}
 import dotty.tools.dotc.parsing.Tokens
 import dotty.tools.dotc.util.Chars
 import dotty.tools.dotc.util.SourcePosition
@@ -474,6 +474,18 @@ object Completion {
         || (mode.is(Mode.Type) && (sym.isType || sym.isStableMember)))
       )
 
+    private def extractRefinements(site: Type)(using Context): Seq[SingleDenotation] =
+      site match
+        case RefinedType(parent, name, info) =>
+          val flags = info match
+            case _: (ExprType | MethodOrPoly) => Method
+            case _ => EmptyFlags
+          val symbol = newSymbol(owner = NoSymbol, name, flags, info)
+          val denot = SymDenotation(symbol, NoSymbol, name, flags, info)
+          denot +: extractRefinements(parent)
+        case tp: TypeProxy => extractRefinements(tp.underlying)
+        case _ => List.empty
+
     /** @param site The type to inspect.
      *  @return The members of `site` that are accessible and pass the include filter.
      */
@@ -488,10 +500,13 @@ object Completion {
         catch
           case ex: TypeError =>
 
-      site.memberDenots(completionsFilter, appendMemberSyms).collect {
+      val members = site.memberDenots(completionsFilter, appendMemberSyms).collect {
         case mbr if include(mbr, mbr.name)
                     && mbr.symbol.isAccessibleFrom(site) => mbr
       }
+      val refinements = extractRefinements(site).filter(mbr => include(mbr, mbr.name))
+
+      members ++ refinements
     }
 
     /**
@@ -504,8 +519,7 @@ object Completion {
     private def implicitConversionTargets(qual: Tree)(using Context): Set[Type] = {
       val typer = ctx.typer
       val conversions = new typer.ImplicitSearch(defn.AnyType, qual, pos.span).allImplicits
-      val convertedTrees = conversions.flatMap(typer.tryApplyingImplicitConversion(_, qual))
-      val targets = convertedTrees.map(_.tpe.finalResultType)
+      val targets = conversions.map(_.tree.tpe)
 
       interactiv.println(i"implicit conversion targets considered: ${targets.toList}%, %")
       targets

compiler/src/dotty/tools/dotc/reporting/ErrorMessageID.scala

@@ -1,12 +1,16 @@
 package dotty.tools.dotc.reporting
 
-/** Unique IDs identifying the messages
+//////////////////////////////////////////////////////////////////////////
+// IMPORTANT                                                            //
+// Only add new IDs at end of the enumeration list and never remove IDs //
+//////////////////////////////////////////////////////////////////////////
+
+/** Unique IDs identifying the messages, this will be used to reference documentation online.
+ *
  *  @param isActive Whether or not the compile still emits this ErrorMessageID
  **/
 enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMessageID]:
 
-  // IMPORTANT: Add new IDs only at the end and never remove IDs
-  case LazyErrorId // // errorNumber: -2
   case NoExplanationID // errorNumber: -1
 
   case EmptyCatchOrFinallyBlockID extends ErrorMessageID(isActive = false) // errorNumber: 0
@@ -180,12 +184,12 @@ enum ErrorMessageID(val isActive: Boolean = true) extends java.lang.Enum[ErrorMe
   case ImplicitSearchTooLargeID // errorNumber: 168
   case TargetNameOnTopLevelClassID // errorNumber: 169
 
-  def errorNumber = ordinal - 2
+  def errorNumber = ordinal - 1
 
 object ErrorMessageID:
   def fromErrorNumber(n: Int): Option[ErrorMessageID] =
-    val enumId = n + 2
-    if enumId >= 2 && enumId < ErrorMessageID.values.length then
+    val enumId = n + 1
+    if enumId >= 1 && enumId < ErrorMessageID.values.length then
       Some(fromOrdinal(enumId))
     else
       None

compiler/src/dotty/tools/dotc/reporting/Message.scala

@@ -43,7 +43,7 @@ object Message {
   * Instead use the `persist` method to create an instance that does not keep a
   * reference to these contexts.
   *
-  * @param errorId a unique id identifying the message, this will later be
+  * @param errorId a unique id identifying the message, this will be
   *                used to reference documentation online
   */
 abstract class Message(val errorId: ErrorMessageID) { self =>

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

@@ -82,11 +82,26 @@ object SymUtils:
     *  parameter section.
     */
     def whyNotGenericProduct(using Context): String =
+      /** for a case class, if it will have an anonymous mirror,
+       *  check that its constructor can be accessed
+       *  from the calling scope.
+       */
+      def canAccessCtor: Boolean =
+        def isAccessible(sym: Symbol): Boolean = ctx.owner.isContainedIn(sym)
+        def isSub(sym: Symbol): Boolean = ctx.owner.ownersIterator.exists(_.derivesFrom(sym))
+        val ctor = self.primaryConstructor
+        (!ctor.isOneOf(Private | Protected) || isSub(self)) // we cant access the ctor because we do not extend cls
+        && (!ctor.privateWithin.exists || isAccessible(ctor.privateWithin)) // check scope is compatible
+
+
+      def companionMirror = self.useCompanionAsProductMirror
       if (!self.is(CaseClass)) "it is not a case class"
       else if (self.is(Abstract)) "it is an abstract class"
       else if (self.primaryConstructor.info.paramInfoss.length != 1) "it takes more than one parameter list"
       else if (isDerivedValueClass(self)) "it is a value class"
+      else if (!(companionMirror || canAccessCtor)) s"the constructor of $self is innaccessible from the calling scope."
       else ""
+    end whyNotGenericProduct
 
     def isGenericProduct(using Context): Boolean = whyNotGenericProduct.isEmpty
 
@@ -120,6 +135,9 @@ object SymUtils:
       self.isOneOf(FinalOrInline, butNot = Mutable)
       && (!self.is(Method) || self.is(Accessor))
 
+    def useCompanionAsProductMirror(using Context): Boolean =
+      self.linkedClass.exists && !self.is(Scala2x) && !self.linkedClass.is(Case)
+
     def useCompanionAsSumMirror(using Context): Boolean =
       def companionExtendsSum(using Context): Boolean =
         self.linkedClass.isSubClass(defn.Mirror_SumClass)
@@ -145,39 +163,39 @@ object SymUtils:
     *     and also the location of the generated mirror.
     *   - all of its children are generic products, singletons, or generic sums themselves.
     */
-    def whyNotGenericSum(declScope: Symbol)(using Context): String =
+    def whyNotGenericSum(using Context): String =
       if (!self.is(Sealed))
         s"it is not a sealed ${self.kindString}"
       else if (!self.isOneOf(AbstractOrTrait))
         "it is not an abstract class"
       else {
         val children = self.children
         val companionMirror = self.useCompanionAsSumMirror
-        assert(!(companionMirror && (declScope ne self.linkedClass)))
         def problem(child: Symbol) = {
 
           def isAccessible(sym: Symbol): Boolean =
-            (self.isContainedIn(sym) && (companionMirror || declScope.isContainedIn(sym)))
+            (self.isContainedIn(sym) && (companionMirror || ctx.owner.isContainedIn(sym)))
             || sym.is(Module) && isAccessible(sym.owner)
 
           if (child == self) "it has anonymous or inaccessible subclasses"
           else if (!isAccessible(child.owner)) i"its child $child is not accessible"
-          else if (!child.isClass) ""
+          else if (!child.isClass) "" // its a singleton enum value
           else {
             val s = child.whyNotGenericProduct
-            if (s.isEmpty) s
-            else if (child.is(Sealed)) {
-              val s = child.whyNotGenericSum(if child.useCompanionAsSumMirror then child.linkedClass else ctx.owner)
-              if (s.isEmpty) s
+            if s.isEmpty then s
+            else if child.is(Sealed) then
+              val s = child.whyNotGenericSum
+              if s.isEmpty then s
               else i"its child $child is not a generic sum because $s"
-            } else i"its child $child is not a generic product because $s"
+            else
+              i"its child $child is not a generic product because $s"
           }
         }
         if (children.isEmpty) "it does not have subclasses"
         else children.map(problem).find(!_.isEmpty).getOrElse("")
       }
 
-    def isGenericSum(declScope: Symbol)(using Context): Boolean = whyNotGenericSum(declScope).isEmpty
+    def isGenericSum(using Context): Boolean = whyNotGenericSum.isEmpty
 
     /** If this is a constructor, its owner: otherwise this. */
     final def skipConstructor(using Context): Symbol =

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

@@ -594,9 +594,9 @@ class SyntheticMembers(thisPhase: DenotTransformer) {
     if (clazz.is(Module)) {
       if (clazz.is(Case)) makeSingletonMirror()
       else if (linked.isGenericProduct) makeProductMirror(linked)
-      else if (linked.isGenericSum(clazz)) makeSumMirror(linked)
+      else if (linked.isGenericSum) makeSumMirror(linked)
       else if (linked.is(Sealed))
-        derive.println(i"$linked is not a sum because ${linked.whyNotGenericSum(clazz)}")
+        derive.println(i"$linked is not a sum because ${linked.whyNotGenericSum}")
     }
     else if (impl.removeAttachment(ExtendsSingletonMirror).isDefined)
       makeSingletonMirror()

compiler/src/dotty/tools/dotc/transform/init/Errors.scala

@@ -9,26 +9,21 @@ import util.SourcePosition
 import Decorators._, printing.SyntaxHighlighting
 import Types._, Symbols._, Contexts._
 
-object Errors {
-  type Errors = Seq[Error]
-  val empty: Errors = Nil
-
-  def show(errs: Errors)(using Context): String =
-    errs.map(_.show).mkString(", ")
+import scala.collection.mutable
 
+object Errors:
   sealed trait Error {
-    def source: Tree
     def trace: Seq[Tree]
     def show(using Context): String
 
-    def issue(using Context): Unit =
-      report.warning(show + stacktrace, source.srcPos)
+    def pos(using Context): SourcePosition = trace.last.sourcePos
 
-    def toErrors: Errors = this :: Nil
+    def issue(using Context): Unit =
+      report.warning(show + stacktrace, this.pos)
 
-    def stacktrace(using Context): String = if (trace.isEmpty) "" else " Calling trace:\n" + {
-      var last: String = ""
-      val sb = new StringBuilder
+    def stacktrace(using Context): String = if trace.isEmpty then "" else " Calling trace:\n" + {
+      var lastLineNum = -1
+      var lines: mutable.ArrayBuffer[String] = new mutable.ArrayBuffer
       trace.foreach { tree =>
         val pos = tree.sourcePos
         val prefix = "-> "
@@ -44,10 +39,16 @@ object Errors {
             positionMarker(pos)
           else ""
 
-        if (last != line)  sb.append(prefix + line + "\n" + positionMarkerLine )
+        // always use the more precise trace location
+        if lastLineNum == pos.line then
+          lines.dropRightInPlace(1)
 
-        last = line
+        lines += (prefix + line + "\n" + positionMarkerLine)
+
+        lastLineNum = pos.line
       }
+      val sb = new StringBuilder
+      for line <- lines do sb.append(line)
       sb.toString
     }
 
@@ -65,13 +66,6 @@ object Errors {
       s"$padding$carets\n"
     }
 
-    /** Flatten UnsafePromotion errors
-     */
-    def flatten: Errors = this match {
-      case unsafe: UnsafePromotion => unsafe.errors.flatMap(_.flatten)
-      case _ => this :: Nil
-    }
-
     override def toString() = this.getClass.getName.nn
   }
 
@@ -81,42 +75,37 @@ object Errors {
     def show(using Context): String =
       "Access non-initialized " + field.show + "."
 
-    override def issue(using Context): Unit =
-      report.warning(show + stacktrace, field.srcPos)
+    override def pos(using Context): SourcePosition = field.sourcePos
   }
 
-  /** Promote `this` under initialization to fully-initialized */
-  case class PromoteError(msg: String, source: Tree, trace: Seq[Tree]) extends Error {
-    def show(using Context): String = "Cannot prove that the value is fully initialized. " + msg + "."
+  /** Promote a value under initialization to fully-initialized */
+  case class PromoteError(msg: String, trace: Seq[Tree]) extends Error {
+    def show(using Context): String = msg
   }
 
-  case class AccessCold(field: Symbol, source: Tree, trace: Seq[Tree]) extends Error {
+  case class AccessCold(field: Symbol, trace: Seq[Tree]) extends Error {
     def show(using Context): String =
-      "Access field " + source.show + " on a value with an unknown initialization status."
+      "Access field on a value with an unknown initialization status."
   }
 
-  case class CallCold(meth: Symbol, source: Tree, trace: Seq[Tree]) extends Error {
+  case class CallCold(meth: Symbol, trace: Seq[Tree]) extends Error {
     def show(using Context): String =
-      "Call method " + source.show + " on a value with an unknown initialization" + "."
+      "Call method on a value with an unknown initialization" + "."
   }
 
-  case class CallUnknown(meth: Symbol, source: Tree, trace: Seq[Tree]) extends Error {
+  case class CallUnknown(meth: Symbol, trace: Seq[Tree]) extends Error {
     def show(using Context): String =
       val prefix = if meth.is(Flags.Method) then "Calling the external method " else "Accessing the external field"
       prefix + meth.show + " may cause initialization errors" + "."
   }
 
   /** Promote a value under initialization to fully-initialized */
-  case class UnsafePromotion(msg: String, source: Tree, trace: Seq[Tree], errors: Errors) extends Error {
-    assert(errors.nonEmpty)
+  case class UnsafePromotion(msg: String, trace: Seq[Tree], error: Error) extends Error {
     override def issue(using Context): Unit =
-      report.warning(show, source.srcPos)
+      report.warning(show, this.pos)
 
-    def show(using Context): String = {
-      var index = 0
-      "Cannot prove that the value is fully initialized. " + msg + ".\n" + stacktrace +
-        "\nThe unsafe promotion may cause the following problem:\n" +
-        errors.head.show + errors.head.stacktrace
-    }
+    def show(using Context): String =
+      msg + stacktrace + "\n" +
+        "Promoting the value to fully initialized failed due to the following problem:\n" +
+        error.show + error.stacktrace
   }
-}