Merge branch 'master' of https://github.com/lampepfl/dotty

Author: bjornregnell

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

@@ -2207,7 +2207,9 @@ object SymDenotations {
       if !myCompanion.exists then
         ensureCompleted()
       myCompanion
-    override def registeredCompanion_=(c: Symbol) = { myCompanion = c }
+
+    override def registeredCompanion_=(c: Symbol) = 
+      myCompanion = c 
 
     private var myNestingLevel = -1
 
@@ -2458,6 +2460,7 @@ object SymDenotations {
       || owner.isRefinementClass
       || owner.is(Scala2x)
       || owner.unforcedDecls.contains(denot.name, denot.symbol)
+      || (denot.is(Synthetic) && denot.is(ModuleClass) && stillValidInOwner(denot.companionClass))
       || denot.isSelfSym
       || denot.isLocalDummy)
   catch case ex: StaleSymbol => false

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

@@ -5343,14 +5343,11 @@ object Types {
     def isExpandingBounds: Boolean = expandingBounds
 
     protected def expandBounds(tp: TypeBounds): Type =
-      if expandingBounds then tp
-      else {
-        val saved = expandingBounds
-        expandingBounds = true
-        val res = range(atVariance(-variance)(reapply(tp.lo)), reapply(tp.hi))
-        expandingBounds = saved
-        res
-      }
+      val saved = expandingBounds
+      expandingBounds = true
+      val res = range(atVariance(-variance)(reapply(tp.lo)), reapply(tp.hi))
+      expandingBounds = saved
+      res
 
     /** Try to widen a named type to its info relative to given prefix `pre`, where possible.
      *  The possible cases are listed inline in the code.

compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala

@@ -349,13 +349,19 @@ class ClassfileParser(
       val tag = sig(index); index += 1
       (tag: @switch) match {
         case 'L' =>
-          def processInner(tp: Type): Type = tp match {
-            case tp: TypeRef if !tp.symbol.owner.is(Flags.ModuleClass) =>
-              TypeRef(processInner(tp.prefix.widen), tp.symbol.asType)
-            case _ =>
-              tp
-          }
-          def processClassType(tp: Type): Type = tp match {
+          /** A type representation where inner classes become `A#B` instead of `A.this.B` (like with `typeRef`)
+           *
+           *  Note: the symbol must not be nested in a generic class.
+           */
+          def innerType(symbol: Symbol): Type =
+            if symbol.is(Flags.Package) then
+              symbol.thisType
+            else if symbol.isType then
+              TypeRef(innerType(symbol.owner), symbol)
+            else
+              throw new RuntimeException("unexpected term symbol " + symbol)
+
+          def processTypeArgs(tp: Type): Type = tp match {
             case tp: TypeRef =>
               if (sig(index) == '<') {
                 accept('<')
@@ -388,13 +394,13 @@ class ClassfileParser(
           }
 
           val classSym = classNameToSymbol(subName(c => c == ';' || c == '<'))
-          val classTpe = if (classSym eq defn.ObjectClass) defn.FromJavaObjectType else classSym.typeRef
-          var tpe = processClassType(processInner(classTpe))
+          val classTpe = if (classSym eq defn.ObjectClass) defn.FromJavaObjectType else innerType(classSym)
+          var tpe = processTypeArgs(classTpe)
           while (sig(index) == '.') {
             accept('.')
             val name = subName(c => c == ';' || c == '<' || c == '.').toTypeName
-            val clazz = tpe.member(name).symbol
-            tpe = processClassType(processInner(TypeRef(tpe, clazz)))
+            val tp = tpe.select(name)
+            tpe = processTypeArgs(tp)
           }
           accept(';')
           tpe
@@ -432,15 +438,15 @@ class ClassfileParser(
             paramtypes += {
               if isRepeatedParam(index) then
                 index += 1
-                val elemType = sig2type(tparams, skiptvs)
+                val elemType = sig2type(tparams, skiptvs = false)
                 // `ElimRepeated` is responsible for correctly erasing this.
                 defn.RepeatedParamType.appliedTo(elemType)
               else
-                sig2type(tparams, skiptvs)
+                sig2type(tparams, skiptvs = false)
             }
 
           index += 1
-          val restype = sig2type(tparams, skiptvs)
+          val restype = sig2type(tparams, skiptvs = false)
           JavaMethodType(paramnames.toList, paramtypes.toList, restype)
         case 'T' =>
           val n = subName(';'.==).toTypeName

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

@@ -21,6 +21,7 @@ import typer.{NoChecking, LiftErased}
 import typer.Inliner
 import typer.ProtoTypes._
 import typer.ErrorReporting.errorTree
+import typer.Checking.checkValue
 import core.TypeErasure._
 import core.Decorators._
 import dotty.tools.dotc.ast.{tpd, untpd}
@@ -569,18 +570,6 @@ object Erasure {
 
     /** Check that Java statics and packages can only be used in selections.
       */
-    private def checkValue(tree: Tree, proto: Type)(using Context): tree.type =
-      if (!proto.isInstanceOf[SelectionProto] && !proto.isInstanceOf[ApplyingProto]) then
-        checkValue(tree)
-      tree
-
-    private def checkValue(tree: Tree)(using Context): Unit =
-      val sym = tree.tpe.termSymbol
-      if (sym is Flags.Package)
-         || (sym.isAllOf(Flags.JavaModule) && !ctx.isJava)
-      then
-        report.error(JavaSymbolIsNotAValue(sym), tree.srcPos)
-
     private def checkNotErased(tree: Tree)(using Context): tree.type = {
       if (!ctx.mode.is(Mode.Type)) {
         if (isErased(tree))
@@ -644,7 +633,7 @@ object Erasure {
         super.typedLiteral(tree)
 
     override def typedIdent(tree: untpd.Ident, pt: Type)(using Context): Tree =
-      checkValue(checkNotErased(super.typedIdent(tree, pt)), pt)
+      checkNotErased(super.typedIdent(tree, pt))
 
     /** Type check select nodes, applying the following rewritings exhaustively
      *  on selections `e.m`, where `OT` is the type of the owner of `m` and `ET`
@@ -772,7 +761,7 @@ object Erasure {
         }
       }
 
-      checkValue(checkNotErased(recur(qual1)), pt)
+      checkNotErased(recur(qual1))
     }
 
     override def typedThis(tree: untpd.This)(using Context): Tree =

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

@@ -258,7 +258,7 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
            && !wasOneOf(getter, Deferred)
            && !getter.isConstExprFinalVal
       yield
-        if (isCurrent(getter) || getter.name.is(ExpandedName)) {
+        if (isInImplementingClass(getter) || getter.name.is(ExpandedName)) {
           val rhs =
             if (wasOneOf(getter, ParamAccessor))
               nextArgument()
@@ -271,6 +271,9 @@ class Mixin extends MiniPhase with SymTransformer { thisPhase =>
           // transformFollowing call is needed to make memoize & lazy vals run
           transformFollowing(DefDef(mkForwarderSym(getter.asTerm), rhs))
         }
+        else if wasOneOf(getter, ParamAccessor) then
+          // mixin parameter field is defined by an override; evaluate the argument and throw it away
+          nextArgument()
         else EmptyTree
     }
 

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

@@ -42,7 +42,7 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
   /** Is `sym` a member of implementing class `cls`?
    *  The test is performed at phase `thisPhase`.
    */
-  def isCurrent(sym: Symbol): Boolean =
+  def isInImplementingClass(sym: Symbol): Boolean =
     atPhase(thisPhase) {
       cls.info.nonPrivateMember(sym.name).hasAltWith(_.symbol == sym)
     }
@@ -71,7 +71,7 @@ class MixinOps(cls: ClassSymbol, thisPhase: DenotTransformer)(using Context) {
     meth.is(Method, butNot = PrivateOrAccessorOrDeferred) &&
     (ctx.settings.mixinForwarderChoices.isTruthy || meth.owner.is(Scala2x) || needsDisambiguation || hasNonInterfaceDefinition ||
      generateJUnitForwarder || generateSerializationForwarder) &&
-    isCurrent(meth)
+    isInImplementingClass(meth)
   }
 
   final val PrivateOrAccessor: FlagSet = Private | Accessor

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

@@ -509,14 +509,22 @@ trait Applications extends Compatibility {
       if (success) formals match {
         case formal :: formals1 =>
 
+          def checkNoVarArg(arg: Arg) =
+            if !ctx.isAfterTyper && isVarArg(arg) then
+              val addendum =
+                if formal.isRepeatedParam then
+                  i"it is not the only argument to be passed to the corresponding repeated parameter $formal"
+                else
+                  i"the corresponding parameter has type $formal which is not a repeated parameter type"
+              fail(em"Sequence argument type annotation `*` cannot be used here:\n$addendum", arg)
+
           /** Add result of typing argument `arg` against parameter type `formal`.
            *  @return  The remaining formal parameter types. If the method is parameter-dependent
            *           this means substituting the actual argument type for the current formal parameter
            *           in the remaining formal parameters.
            */
-          def addTyped(arg: Arg, formal: Type): List[Type] =
-            if !ctx.isAfterTyper && isVarArg(arg) && !formal.isRepeatedParam then
-              fail(i"Sequence argument type annotation `: _*` cannot be used here: the corresponding parameter has type $formal which is not a repeated parameter type", arg)
+          def addTyped(arg: Arg): List[Type] =
+            if !formal.isRepeatedParam then checkNoVarArg(arg)
             addArg(typedArg(arg, formal), formal)
             if methodType.isParamDependent && typeOfArg(arg).exists then
               // `typeOfArg(arg)` could be missing because the evaluation of `arg` produced type errors
@@ -553,31 +561,36 @@ trait Applications extends Compatibility {
             def implicitArg = implicitArgTree(formal, appPos.span)
 
             if !defaultArg.isEmpty then
-              matchArgs(args1, addTyped(treeToArg(defaultArg), formal), n + 1)
+              matchArgs(args1, addTyped(treeToArg(defaultArg)), n + 1)
             else if methodType.isContextualMethod && ctx.mode.is(Mode.ImplicitsEnabled) then
-              matchArgs(args1, addTyped(treeToArg(implicitArg), formal), n + 1)
+              matchArgs(args1, addTyped(treeToArg(implicitArg)), n + 1)
             else
               missingArg(n)
           }
 
           if (formal.isRepeatedParam)
             args match {
               case arg :: Nil if isVarArg(arg) =>
-                addTyped(arg, formal)
+                addTyped(arg)
               case (arg @ Typed(Literal(Constant(null)), _)) :: Nil if ctx.isAfterTyper =>
-                addTyped(arg, formal)
+                addTyped(arg)
               case _ =>
                 val elemFormal = formal.widenExpr.argTypesLo.head
                 val typedArgs =
-                  harmonic(harmonizeArgs, elemFormal)(args.map(typedArg(_, elemFormal)))
+                  harmonic(harmonizeArgs, elemFormal) {
+                    args.map { arg =>
+                      checkNoVarArg(arg)
+                      typedArg(arg, elemFormal)
+                    }
+                  }
                 typedArgs.foreach(addArg(_, elemFormal))
                 makeVarArg(args.length, elemFormal)
             }
           else args match {
             case EmptyTree :: args1 =>
               tryDefault(n, args1)
             case arg :: args1 =>
-              matchArgs(args1, addTyped(arg, formal), n + 1)
+              matchArgs(args1, addTyped(arg), n + 1)
             case nil =>
               tryDefault(n, args)
           }

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

@@ -653,6 +653,21 @@ object Checking {
        || to.isRef(defn.ObjectClass, skipRefined = false)
     then
       report.error(em"the result of an implicit conversion must be more specific than $to", pos)
+
+  def checkValue(tree: Tree)(using Context): Unit =
+    val sym = tree.tpe.termSymbol
+    if sym.is(Flags.Package) || sym.isAllOf(Flags.JavaModule) && !ctx.isJava then
+      report.error(JavaSymbolIsNotAValue(sym), tree.srcPos)
+
+  def checkValue(tree: Tree, proto: Type)(using Context): tree.type =
+    tree match
+      case tree: RefTree
+      if tree.name.isTermName
+         && !proto.isInstanceOf[SelectionProto]
+         && !proto.isInstanceOf[FunOrPolyProto] =>
+        checkValue(tree)
+      case _ =>
+    tree
 }
 
 trait Checking {

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

@@ -158,7 +158,8 @@ class Typer extends Namer
      */
     def qualifies(denot: Denotation): Boolean =
       reallyExists(denot)
-      && !(pt.isInstanceOf[UnapplySelectionProto] && denot.symbol.is(Method, butNot = Accessor))
+      && (!pt.isInstanceOf[UnapplySelectionProto]
+          || denot.hasAltWith(sd => !sd.symbol.is(Method, butNot = Accessor)))
       && !denot.symbol.is(PackageClass)
 
     /** Find the denotation of enclosing `name` in given context `ctx`.
@@ -499,7 +500,7 @@ class Typer extends Namer
         case _ =>
           tree.withType(ownType)
       val tree2 = toNotNullTermRef(tree1, pt)
-      checkStableIdentPattern(tree2, pt)
+      checkLegalValue(tree2, pt)
       tree2
 
     def isLocalExtensionMethodRef: Boolean = rawType match
@@ -537,9 +538,12 @@ class Typer extends Namer
       errorTree(tree, MissingIdent(tree, kind, name))
   end typedIdent
 
-  /** Check that a stable identifier pattern is indeed stable (SLS 8.1.5)
+  /** (1) If this reference is neither applied nor selected, check that it does
+   *      not refer to a package or Java companion object.
+   *  (2) Check that a stable identifier pattern is indeed stable (SLS 8.1.5)
    */
-  private def checkStableIdentPattern(tree: Tree, pt: Type)(using Context): Unit =
+  private def checkLegalValue(tree: Tree, pt: Type)(using Context): Unit =
+    checkValue(tree, pt)
     if ctx.mode.is(Mode.Pattern)
        && !tree.isType
        && !pt.isInstanceOf[ApplyingProto]
@@ -557,7 +561,7 @@ class Typer extends Namer
     if checkedType.exists then
       val select = toNotNullTermRef(assignType(tree, checkedType), pt)
       if selName.isTypeName then checkStable(qual.tpe, qual.srcPos, "type prefix")
-      checkStableIdentPattern(select, pt)
+      checkLegalValue(select, pt)
       ConstFold(select)
     else if couldInstantiateTypeVar(qual.tpe.widen) then
       // try again with more defined qualifier type
@@ -2343,7 +2347,7 @@ class Typer extends Namer
       assert(imp.selectors.length == 1, imp)
       val from = imp.selectors.head.imported
       val sel = tryAlternatively
-          (typedIdent(from, WildcardType))
+          (typedIdent(from, AnySelectionProto))
           (typedIdent(cpy.Ident(from)(from.name.toTypeName), WildcardType))
 
       sel.tpe match
@@ -3696,8 +3700,12 @@ class Typer extends Namer
       val Select(qual, nme.apply) = tree; @unchecked
       val tycon = tree.tpe.widen.finalResultType.underlyingClassRef(refinementOK = false)
       val tpt = qual match
-        case Ident(name) => cpy.Ident(qual)(name.toTypeName)
-        case Select(pre, name) => cpy.Select(qual)(pre, name.toTypeName)
+        case Ident(name) =>
+          cpy.Ident(qual)(name.toTypeName)
+        case Select(pre, name) =>
+          cpy.Select(qual)(pre, name.toTypeName)
+        case qual: This if qual.symbol.is(ModuleClass) =>
+          cpy.Ident(qual)(qual.symbol.name.sourceModuleName.toTypeName)
       typed(
         untpd.Select(
           untpd.New(untpd.TypedSplice(tpt.withType(tycon))),

compiler/test/dotty/tools/AnnotationsTests.scala

@@ -29,13 +29,20 @@ class AnnotationsTest:
         val arrayOfString = defn.ArrayType.appliedTo(List(defn.StringType))
 
         atPhase(erasurePhase.next) {
-          val annot = cls.getAnnotation(annotCls)
           // Even though we're forcing the annotation after erasure,
           // the typed trees should be unerased, so the type of
           // the annotation argument should be `arrayOfString` and
           // not a `JavaArrayType`.
+          val annot = cls.getAnnotation(annotCls)
           val arg = annot.get.argument(0).get
-          assert(arg.tpe.isInstanceOf[AppliedType] && arg.tpe =:= arrayOfString,
+
+          // If we run the type check after erasure, we will have
+          // `Array[String] =:= Array[String]` being false.
+          // The reason is that in `TypeComparer.compareAppliedType2` we have
+          // `tycon2.typeParams == Nil` after erasure, thus always get false.
+          val res = atPhase(typerPhase) { arrayOfString =:= arg.tpe }
+
+          assert(arg.tpe.isInstanceOf[AppliedType] && res,
             s"Argument $arg had type:\n${arg.tpe}\nbut expected type:\n$arrayOfString")
         }
       }

compiler/test/dotty/tools/dotc/BootstrappedOnlyCompilationTests.scala

@@ -28,6 +28,7 @@ class BootstrappedOnlyCompilationTests {
       compileFilesInDir("tests/pos-macros", defaultOptions),
       compileFilesInDir("tests/pos-custom-args/semanticdb", defaultOptions.and("-Xsemanticdb")),
       compileDir("tests/pos-special/i7592", defaultOptions.and("-Yretain-trees")),
+      compileDir("tests/pos-special/i11331.1", defaultOptions),
     ).checkCompile()
   }