Merge remote-tracking branch 'origin/2.13.x' into faster/virtual-transform-minimal

Author: retronym

src/compiler/scala/reflect/reify/phases/Reshape.scala

@@ -227,7 +227,7 @@ trait Reshape {
           case NestedAnnotArg(ann)    => toPreTyperAnnotation(ann)
         }
 
-        ann.assocs map { case (nme, arg) => AssignOrNamedArg(Ident(nme), toScalaAnnotation(arg)) }
+        ann.assocs map { case (nme, arg) => NamedArg(Ident(nme), toScalaAnnotation(arg)) }
       }
 
       def extractOriginal: PartialFunction[Tree, Tree] = { case Apply(Select(New(tpt), _), _) => tpt }

src/compiler/scala/tools/nsc/ast/parser/Parsers.scala

@@ -1979,7 +1979,7 @@ self =>
        *  }}}
        */
       def pattern3(): Tree = {
-        val top = simplePattern(badPattern3)
+        val top = simplePattern(() => badPattern3())
         val base = opstack
         // See scala/bug#3189, scala/bug#4832 for motivation. Cf scala/bug#3480 for counter-motivation.
         def isCloseDelim = in.token match {
@@ -1995,7 +1995,7 @@ self =>
           case _ => EmptyTree
         }
         def loop(top: Tree): Tree = reducePatternStack(base, top) match {
-          case next if isIdent && !isRawBar => pushOpInfo(next) ; loop(simplePattern(badPattern3))
+          case next if isIdent && !isRawBar => pushOpInfo(next) ; loop(simplePattern(() => badPattern3()))
           case next                         => next
         }
         checkWildStar orElse stripParens(loop(top))

src/compiler/scala/tools/nsc/ast/parser/Scanners.scala

@@ -554,9 +554,9 @@ trait Scanners extends ScannersCommon {
           def fetchSingleQuote() = {
             nextChar()
             if (isIdentifierStart(ch))
-              charLitOr(getIdentRest)
+              charLitOr(() => getIdentRest())
             else if (isOperatorPart(ch) && (ch != '\\'))
-              charLitOr(getOperatorRest)
+              charLitOr(() => getOperatorRest())
             else if (!isAtEnd && (ch != SU && ch != CR && ch != LF || isUnicodeEscape)) {
               val isEmptyCharLit = (ch == '\'')
               getLitChar()

src/compiler/scala/tools/nsc/backend/jvm/BTypes.scala

@@ -974,7 +974,7 @@ abstract class BTypes {
       }
     }
 
-    def reInitialize(): Unit = frontendSynch(isInit = false)
+    def reInitialize(): Unit = frontendSynch { isInit = false }
   }
 }
 

src/compiler/scala/tools/nsc/javac/JavaParsers.scala

@@ -315,7 +315,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
       if (in.token == LT) {
         in.nextToken()
         val t1 = convertToTypeId(t)
-        val args = repsep(typeArg, COMMA)
+        val args = repsep(() => typeArg(), COMMA)
         acceptClosingAngle()
         atPos(t1.pos) {
           val t2: Tree = AppliedTypeTree(t1, args)
@@ -401,7 +401,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
     def typeParams(): List[TypeDef] =
       if (in.token == LT) {
         in.nextToken()
-        val tparams = repsep(typeParam, COMMA)
+        val tparams = repsep(() => typeParam(), COMMA)
         acceptClosingAngle()
         tparams
       } else List()
@@ -428,7 +428,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
 
     def formalParams(): List[ValDef] = {
       accept(LPAREN)
-      val vparams = if (in.token == RPAREN) List() else repsep(formalParam, COMMA)
+      val vparams = if (in.token == RPAREN) List() else repsep(() => formalParam(), COMMA)
       accept(RPAREN)
       vparams
     }
@@ -449,7 +449,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
     def optThrows() {
       if (in.token == THROWS) {
         in.nextToken()
-        repsep(typ, COMMA)
+        repsep(() => typ(), COMMA)
       }
     }
 
@@ -679,7 +679,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
     def interfacesOpt() =
       if (in.token == IMPLEMENTS) {
         in.nextToken()
-        repsep(typ, COMMA)
+        repsep(() => typ(), COMMA)
       } else {
         List()
       }
@@ -711,7 +711,7 @@ trait JavaParsers extends ast.parser.ParsersCommon with JavaScanners {
       val parents =
         if (in.token == EXTENDS) {
           in.nextToken()
-          repsep(typ, COMMA)
+          repsep(() => typ(), COMMA)
         } else {
           List(javaLangObject())
         }

src/compiler/scala/tools/nsc/settings/ScalaSettings.scala

@@ -89,6 +89,8 @@ trait ScalaSettings extends AbsScalaSettings
   def isScala212: Boolean = source.value >= version212
   private[this] val version213 = ScalaVersion("2.13.0")
   def isScala213: Boolean = source.value >= version213
+  private[this] val version214 = ScalaVersion("2.14.0")
+  def isScala214: Boolean = source.value >= version214
 
   /**
    * -X "Advanced" settings
@@ -133,7 +135,7 @@ trait ScalaSettings extends AbsScalaSettings
   val sourceReader       = StringSetting       ("-Xsource-reader", "classname", "Specify a custom method for reading source files.", "")
   val reporter           = StringSetting       ("-Xreporter", "classname", "Specify a custom reporter for compiler messages.", "scala.tools.nsc.reporters.ConsoleReporter")
   val strictInference    = BooleanSetting      ("-Xstrict-inference", "Don't infer known-unsound types")
-  val source             = ScalaVersionSetting ("-Xsource", "version", "Treat compiler input as Scala source for the specified version, see scala/bug#8126.", initial = ScalaVersion("2.12"))
+  val source             = ScalaVersionSetting ("-Xsource", "version", "Treat compiler input as Scala source for the specified version, see scala/bug#8126.", initial = ScalaVersion("2.13"))
 
   val XnoPatmatAnalysis = BooleanSetting ("-Xno-patmat-analysis", "Don't perform exhaustivity/unreachability analysis. Also, ignore @switch annotation.")
   val XfullLubs         = BooleanSetting ("-Xfull-lubs", "Retains pre 2.10 behavior of less aggressive truncation of least upper bounds.")

src/compiler/scala/tools/nsc/transform/UnCurry.scala

@@ -423,6 +423,7 @@ abstract class UnCurry extends InfoTransform
       def checkIsElidable(sym: Symbol): Boolean = (sym ne null) && sym.elisionLevel.exists { level =>
           if (sym.isMethod) level < settings.elidebelow.value
           else {
+            // TODO: report error? It's already done in RefChecks. https://github.com/scala/scala/pull/5539#issuecomment-331376887
             if (settings.isScala213) reporter.error(sym.pos, s"${sym.name}: Only methods can be marked @elidable.")
             false
           }

src/compiler/scala/tools/nsc/transform/patmat/MatchOptimization.scala

@@ -104,7 +104,7 @@ trait MatchOptimization extends MatchTreeMaking with MatchAnalysis {
               reusedTest <- test.reuses;
               nextDeps <- dependencies.get(reusedTest);
               diff <- (nextDeps -- currDeps).headOption;
-              _ <- Some(currDeps = nextDeps))
+              _ <- Some({ currDeps = nextDeps }))
                 yield diff).nonEmpty
         }
 

src/compiler/scala/tools/nsc/typechecker/ContextErrors.scala

@@ -45,14 +45,6 @@ trait ContextErrors {
   case class NormalTypeError(underlyingTree: Tree, errMsg: String)
     extends TreeTypeError
 
-  /**
-   * Marks a TypeError that was constructed from a CyclicReference (under silent).
-   * This is used for named arguments, where we need to know if an assignment expression
-   * failed with a cyclic reference or some other type error.
-   */
-  class NormalTypeErrorFromCyclicReference(underlyingTree: Tree, errMsg: String)
-    extends NormalTypeError(underlyingTree, errMsg)
-
   case class AccessTypeError(underlyingTree: Tree, errMsg: String)
     extends TreeTypeError
 
@@ -565,7 +557,7 @@ trait ContextErrors {
             }
           }
           val unknowns = (namelessArgs zip args) collect {
-            case (_: Assign, AssignOrNamedArg(Ident(name), _)) => name
+            case (_: Assign, NamedArg(Ident(name), _)) => name
           }
           val suppl = 
             unknowns.size match {
@@ -1128,9 +1120,8 @@ trait ContextErrors {
             // hence we (together with reportTypeError in TypeDiagnostics) make sure that this CyclicReference
             // evades all the handlers on its way and successfully reaches `isCyclicOrErroneous` in Implicits
             throw ex
-          case c @ CyclicReference(sym, info: TypeCompleter) =>
-            val error = new NormalTypeErrorFromCyclicReference(tree, typer.cyclicReferenceMessage(sym, info.tree) getOrElse ex.getMessage)
-            issueTypeError(error)
+          case CyclicReference(sym, info: TypeCompleter) =>
+            issueNormalTypeError(tree, typer.cyclicReferenceMessage(sym, info.tree) getOrElse ex.getMessage)
           case _ =>
             contextNamerErrorGen.issue(TypeErrorWithUnderlyingTree(tree, ex))
         }
@@ -1322,23 +1313,12 @@ trait ContextErrors {
       issueSymbolTypeError(sym, errMsg)
     }
 
-    def AmbiguousReferenceInNamesDefaultError(arg: Tree, name: Name)(implicit context: Context) = {
-      if (!arg.isErroneous) { // check if name clash wasn't reported already
-        issueNormalTypeError(arg,
-          "reference to "+ name +" is ambiguous; it is both a method parameter "+
-          "and a variable in scope.")
-        setError(arg)
-      } else arg
-    }
-
-    def WarnAfterNonSilentRecursiveInference(param: Symbol, arg: Tree)(implicit context: Context) = {
-      val note = "failed to determine if '"+ param.name + " = ...' is a named argument or an assignment expression.\n"+
-                 "an explicit type is required for the definition mentioned in the error message above."
-      context.warning(arg.pos, note)
-    }
-
-    def UnknownParameterNameNamesDefaultError(arg: Tree, name: Name)(implicit context: Context) = {
-      issueNormalTypeError(arg, "unknown parameter name: " + name)
+    def UnknownParameterNameNamesDefaultError(arg: Tree, name: Name, warnVariableInScope: Boolean)(implicit context: Context) = {
+      val suffix =
+        if (warnVariableInScope)
+          s"\nNote that assignments in argument position are no longer allowed since Scala 2.13.\nTo express the assignment expression, wrap it in brackets, e.g., `{ $name = ... }`."
+        else ""
+      issueNormalTypeError(arg, s"unknown parameter name: $name$suffix")
       setError(arg)
     }
 

src/compiler/scala/tools/nsc/typechecker/NamesDefaults.scala

@@ -50,9 +50,9 @@ trait NamesDefaults { self: Analyzer =>
     blockTyper: Typer
   ) { }
 
-  private def nameOfNamedArg(arg: Tree) = Some(arg) collect { case AssignOrNamedArg(Ident(name), _) => name }
+  private def nameOfNamedArg(arg: Tree) = Some(arg) collect { case NamedArg(Ident(name), _) => name }
   def isNamedArg(arg: Tree) = arg match {
-    case AssignOrNamedArg(Ident(_), _) => true
+    case NamedArg(Ident(_), _) => true
     case _                             => false
   }
 
@@ -452,7 +452,7 @@ trait NamesDefaults { self: Analyzer =>
               Apply(tree, args.map(_.duplicate)))
             Some(atPos(pos) {
               if (positional) default2
-              else AssignOrNamedArg(Ident(p.name), default2)
+              else NamedArg(Ident(p.name), default2)
             })
           }
         })
@@ -486,78 +486,6 @@ trait NamesDefaults { self: Analyzer =>
     } else NoSymbol
   }
 
-  /** A full type check is very expensive; let's make sure there's a name
-   *  somewhere which could potentially be ambiguous before we go that route.
-   */
-  private def isAmbiguousAssignment(typer: Typer, param: Symbol, arg: Tree) = {
-    import typer.context
-    (context isNameInScope param.name) && {
-      // for named arguments, check whether the assignment expression would
-      // typecheck. if it does, report an ambiguous error.
-      val paramtpe = param.tpe.cloneInfo(param)
-      // replace type parameters by wildcard. in the below example we need to
-      // typecheck (x = 1) with wildcard (not T) so that it succeeds.
-      //   def f[T](x: T) = x
-      //   var x = 0
-      //   f(x = 1)   <<  "x = 1" typechecks with expected type WildcardType
-      val udp = context.undetparams
-      context.savingUndeterminedTypeParams(reportAmbiguous = false) {
-        val subst = new SubstTypeMap(udp, udp map (_ => WildcardType)) {
-          override def apply(tp: Type): Type = super.apply(dropByName(tp))
-        }
-        // This throws an exception which is caught in `tryTypedApply` (as it
-        // uses `silent`) - unfortunately, tryTypedApply recovers from the
-        // exception if you use errorTree(arg, ...) and conforms is allowed as
-        // a view (see tryImplicit in Implicits) because it tries to produce a
-        // new qualifier (if the old one was P, the new one will be
-        // conforms.apply(P)), and if that works, it pretends nothing happened.
-        //
-        // To make sure tryTypedApply fails, we would like to pass EmptyTree
-        // instead of arg, but can't do that because eventually setType(ErrorType)
-        // is called, and EmptyTree can only be typed NoType.  Thus we need to
-        // disable conforms as a view...
-        val errsBefore = reporter.ERROR.count
-        try typer.silent { tpr =>
-          val res = tpr.typed(arg.duplicate, subst(paramtpe))
-          // better warning for scala/bug#5044: if `silent` was not actually silent give a hint to the user
-          // [H]: the reason why `silent` is not silent is because the cyclic reference exception is
-          // thrown in a context completely different from `context` here. The exception happens while
-          // completing the type, and TypeCompleter is created/run with a non-silent Namer `context`
-          // and there is at the moment no way to connect the two unless we go through some global state.
-          if (errsBefore < reporter.ERROR.count)
-            WarnAfterNonSilentRecursiveInference(param, arg)(context)
-          res
-        } match {
-          case SilentResultValue(t)  =>
-            !t.isErroneous // #4041
-          case SilentTypeError(e: NormalTypeErrorFromCyclicReference) =>
-            // If we end up here, the CyclicReference was reported in a silent context. This can
-            // happen for local definitions, when the completer for a definition is created during
-            // type checking in silent mode. ContextErrors.TypeSigError catches that cyclic reference
-            // and transforms it into a NormalTypeErrorFromCyclicReference.
-            // The cycle needs to be reported, because the program cannot be typed: we don't know
-            // if we have an assignment or a named arg.
-            context.issue(e)
-            // 'err = true' is required because we're in a silent context
-            WarnAfterNonSilentRecursiveInference(param, arg)(context)
-            false
-          case _        =>
-            // We got a type error, so it cannot be an assignment (it doesn't type check as one).
-            false
-        }
-        catch {
-          // `silent` only catches and returns TypeErrors which are not
-          // CyclicReferences.  Fix for #3685
-          case cr @ CyclicReference(sym, _) =>
-            (sym.name == param.name) && sym.accessedOrSelf.isVariable && {
-              NameClashError(sym, arg)(context)
-              true
-            }
-        }
-      }
-    }
-  }
-
   /** Removes name assignments from args. Additionally, returns an array mapping
    *  argument indices from call-site-order to definition-site-order.
    *
@@ -590,23 +518,18 @@ trait NamesDefaults { self: Analyzer =>
     val argPos       = Array.fill(args.length)(-1)
     val namelessArgs = {
       var positionalAllowed = true
-      def stripNamedArg(arg: AssignOrNamedArg, argIndex: Int): Tree = {
-        val AssignOrNamedArg(Ident(name), rhs) = arg
+      def stripNamedArg(arg: NamedArg, argIndex: Int): Tree = {
+        val NamedArg(Ident(name), rhs) = arg
         params indexWhere (p => matchesName(p, name, argIndex)) match {
-          case -1 if positionalAllowed =>
-            // prevent isNamed from being true when calling doTypedApply recursively,
-            // treat the arg as an assignment of type Unit
-            Assign(arg.lhs, rhs) setPos arg.pos
           case -1 =>
-            UnknownParameterNameNamesDefaultError(arg, name)
+            val warnVariableInScope = !settings.isScala214 && context0.lookupSymbol(name, _.isVariable).isSuccess
+            UnknownParameterNameNamesDefaultError(arg, name, warnVariableInScope)
           case paramPos if argPos contains paramPos =>
             val existingArgIndex = argPos.indexWhere(_ == paramPos)
             val otherName = Some(args(paramPos)) collect {
-              case AssignOrNamedArg(Ident(oName), _) if oName != name => oName
+              case NamedArg(Ident(oName), _) if oName != name => oName
             }
             DoubleParamNamesDefaultError(arg, name, existingArgIndex+1, otherName)
-          case paramPos if isAmbiguousAssignment(typer, params(paramPos), arg) =>
-            AmbiguousReferenceInNamesDefaultError(arg, name)
           case paramPos if paramPos != argIndex =>
             positionalAllowed = false    // named arg is not in original parameter order: require names after this
             argPos(argIndex)  = paramPos // fix up the arg position
@@ -615,7 +538,7 @@ trait NamesDefaults { self: Analyzer =>
         }
       }
       mapWithIndex(args) {
-        case (arg: AssignOrNamedArg, argIndex) =>
+        case (arg: NamedArg, argIndex) =>
           val t = stripNamedArg(arg, argIndex)
           if (!t.isErroneous && argPos(argIndex) < 0) argPos(argIndex) = argIndex
           t

src/compiler/scala/tools/nsc/typechecker/RefChecks.scala

@@ -1413,8 +1413,10 @@ abstract class RefChecks extends Transform {
       }
 
       def checkIsElidable(sym: Symbol): Unit = if (sym ne null) sym.elisionLevel.foreach { level =>
-        if (!sym.isMethod || sym.isAccessor || sym.isLazy || sym.isDeferred)
-          reporter.error(sym.pos, s"${sym.name}: Only methods can be marked @elidable.")
+        if (!sym.isMethod || sym.isAccessor || sym.isLazy || sym.isDeferred) {
+          val rest = if (sym.isDeferred) " The annotation affects only the annotated method, not overriding methods in subclasses." else ""
+          reporter.error(sym.pos, s"${sym.name}: Only concrete methods can be marked @elidable.$rest")
+        }
       }
       if (settings.isScala213) checkIsElidable(tree.symbol)