Merge pull request #2716 from dotty-staging/fix-#2570-2

Fix #2570: Part 3 - The great () insert

.gitignore

@@ -70,3 +70,4 @@ compiler/test/debug/Gen.jar
 
 compiler/before-pickling.txt
 compiler/after-pickling.txt
+*.dotty-ide-version

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

@@ -69,7 +69,7 @@ object desugar {
         val originalOwner = sym.owner
         def apply(tp: Type) = tp match {
           case tp: NamedType if tp.symbol.exists && (tp.symbol.owner eq originalOwner) =>
-            val defctx = ctx.outersIterator.dropWhile(_.scope eq ctx.scope).next
+            val defctx = ctx.outersIterator.dropWhile(_.scope eq ctx.scope).next()
             var local = defctx.denotNamed(tp.name).suchThat(_ is ParamOrAccessor).symbol
             if (local.exists) (defctx.owner.thisType select local).dealias
             else {
@@ -538,12 +538,12 @@ object desugar {
     val cdef1 = addEnumFlags {
       val originalTparamsIt = originalTparams.toIterator
       val originalVparamsIt = originalVparamss.toIterator.flatten
-      val tparamAccessors = derivedTparams.map(_.withMods(originalTparamsIt.next.mods))
+      val tparamAccessors = derivedTparams.map(_.withMods(originalTparamsIt.next().mods))
       val caseAccessor = if (isCaseClass) CaseAccessor else EmptyFlags
       val vparamAccessors = derivedVparamss match {
         case first :: rest =>
-          first.map(_.withMods(originalVparamsIt.next.mods | caseAccessor)) ++
-          rest.flatten.map(_.withMods(originalVparamsIt.next.mods))
+          first.map(_.withMods(originalVparamsIt.next().mods | caseAccessor)) ++
+          rest.flatten.map(_.withMods(originalVparamsIt.next().mods))
         case _ =>
           Nil
       }

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

@@ -70,7 +70,7 @@ object NavigateAST {
   def pathTo(pos: Position, from: Positioned, skipZeroExtent: Boolean = false)(implicit ctx: Context): List[Positioned] = {
     def childPath(it: Iterator[Any], path: List[Positioned]): List[Positioned] = {
       while (it.hasNext) {
-        val path1 = it.next match {
+        val path1 = it.next() match {
           case p: Positioned => singlePath(p, path)
           case xs: List[_] => childPath(xs.iterator, path)
           case _ => path

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

@@ -53,7 +53,7 @@ trait TreeInfo[T >: Untyped <: Type] { self: Trees.Instance[T] =>
     def map[R](f: (Symbol, Tree) => R): List[R] = {
       val b = List.newBuilder[R]
       foreach(b += f(_, _))
-      b.result
+      b.result()
     }
   }
 

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

@@ -129,7 +129,7 @@ object Trees {
     private def checkChildrenTyped(it: Iterator[Any])(implicit ctx: Context): Unit =
       if (!this.isInstanceOf[Import[_]])
         while (it.hasNext)
-          it.next match {
+          it.next() match {
             case x: Ident[_] => // untyped idents are used in a number of places in typed trees
             case x: Tree[_] =>
               assert(x.hasType || ctx.reporter.errorsReported,

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

@@ -348,15 +348,15 @@ object Contexts {
      */
     def thisCallArgContext: Context = {
       assert(owner.isClassConstructor)
-      val constrCtx = outersIterator.dropWhile(_.outer.owner == owner).next
+      val constrCtx = outersIterator.dropWhile(_.outer.owner == owner).next()
       superOrThisCallContext(owner, constrCtx.scope)
         .setTyperState(typerState)
         .setGadt(gadt)
     }
 
     /** The super- or this-call context with given owner and locals. */
     private def superOrThisCallContext(owner: Symbol, locals: Scope): FreshContext = {
-      var classCtx = outersIterator.dropWhile(!_.isClassDefContext).next
+      var classCtx = outersIterator.dropWhile(!_.isClassDefContext).next()
       classCtx.outer.fresh.setOwner(owner)
         .setScope(locals)
         .setMode(classCtx.mode | Mode.InSuperCall)

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

@@ -37,7 +37,7 @@ object Decorators {
   implicit class SymbolIteratorDecorator(val it: Iterator[Symbol]) extends AnyVal {
     final def findSymbol(p: Symbol => Boolean): Symbol = {
       while (it.hasNext) {
-        val sym = it.next
+        val sym = it.next()
         if (p(sym)) return sym
       }
       NoSymbol

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

@@ -408,7 +408,8 @@ object Denotations {
 
         /** Sym preference provided types also override */
         def prefer(sym1: Symbol, sym2: Symbol, info1: Type, info2: Type) =
-          preferSym(sym1, sym2) && info1.overrides(info2)
+          preferSym(sym1, sym2) &&
+          info1.overrides(info2, sym1.matchNullaryLoosely || sym2.matchNullaryLoosely)
 
         def handleDoubleDef =
           if (preferSym(sym1, sym2)) denot1
@@ -512,7 +513,7 @@ object Denotations {
                 def lubSym(overrides: Iterator[Symbol], previous: Symbol): Symbol =
                   if (!overrides.hasNext) previous
                   else {
-                    val candidate = overrides.next
+                    val candidate = overrides.next()
                     if (owner2 derivesFrom candidate.owner)
                       if (candidate isAccessibleFrom pre) candidate
                       else lubSym(overrides, previous orElse candidate)
@@ -779,7 +780,7 @@ object Denotations {
       }
 
       if (valid.runId != currentPeriod.runId)
-        if (exists) initial.bringForward.current
+        if (exists) initial.bringForward().current
         else this
       else {
         var cur = this

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

@@ -28,7 +28,7 @@ trait Phases {
     if ((this eq NoContext) || !phase.exists) Nil
     else {
       val rest = outersIterator.dropWhile(_.phase == phase)
-      phase :: (if (rest.hasNext) rest.next.phasesStack else Nil)
+      phase :: (if (rest.hasNext) rest.next().phasesStack else Nil)
     }
 
   /** Execute `op` at given phase */

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

@@ -763,6 +763,20 @@ object SymDenotations {
 
     def isInlineMethod(implicit ctx: Context): Boolean = is(InlineMethod, butNot = Accessor)
 
+    /** ()T and => T types should be treated as equivalent for this symbol.
+     *  Note: For the moment, we treat Scala-2 compiled symbols as loose matching,
+     *  because the Scala library does not always follow the right conventions.
+     *  Examples are: isWhole(), toInt(), toDouble() in BigDecimal, Numeric, RichInt, ScalaNumberProxy.
+     */
+    def matchNullaryLoosely(implicit ctx: Context): Boolean = {
+      def test(sym: Symbol) =
+        sym.is(JavaDefined) ||
+        sym.owner == defn.AnyClass ||
+        sym == defn.Object_clone ||
+        sym.owner.is(Scala2x)
+      test(symbol) || allOverriddenSymbols.exists(test)
+    }
+
     // ------ access to related symbols ---------------------------------
 
     /* Modules and module classes are represented as follows:
@@ -938,7 +952,6 @@ object SymDenotations {
       else if (this.isClass) companionNamed(effectiveName.moduleClassName).sourceModule.moduleClass
       else NoSymbol
 
-
     /** Find companion class symbol with given name, or NoSymbol if none exists.
      *  Three alternative strategies:
      *  1. If owner is a class, look in its members, otherwise
@@ -962,7 +975,7 @@ object SymDenotations {
       else if (ctx.scope.lookup(this.name) == symbol)
         ctx.scope.lookup(name)
       else
-        companionNamed(name)(ctx.outersIterator.dropWhile(_.scope eq ctx.scope).next)
+        companionNamed(name)(ctx.outersIterator.dropWhile(_.scope eq ctx.scope).next())
 
     /** Is this symbol the same or a linked class of `sym`? */
     final def isLinkedWith(sym: Symbol)(implicit ctx: Context): Boolean =

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

@@ -518,8 +518,11 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
   def dynamicsEnabled =
     featureEnabled(defn.LanguageModuleClass, nme.dynamics)
 
-  def testScala2Mode(msg: => String, pos: Position) = {
-    if (scala2Mode) migrationWarning(msg, pos)
+  def testScala2Mode(msg: => String, pos: Position, rewrite: => Unit = ()) = {
+    if (scala2Mode) {
+      migrationWarning(msg, pos)
+      rewrite
+    }
     scala2Mode
   }
 }

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

@@ -769,21 +769,23 @@ object Types {
     def relaxed_<:<(that: Type)(implicit ctx: Context) =
       (this <:< that) || (this isValueSubType that)
 
-    /** Is this type a legal type for a member that overrides another
-     *  member of type `that`? This is the same as `<:<`, except that
-     *  the types `()T`, `=> T` and `T` are seen as overriding
-     *  each other.
+    /** Is this type a legal type for member `sym1` that overrides another
+     *  member `sym2` of type `that`? This is the same as `<:<`, except that
+     *  if `matchLoosely` evaluates to true the types `=> T` and `()T` are seen
+     *  as overriding each other.
      */
-    final def overrides(that: Type)(implicit ctx: Context) = {
-      def result(tp: Type): Type = tp match {
-        case ExprType(_) | MethodType(Nil) => tp.resultType
+    final def overrides(that: Type, matchLoosely: => Boolean)(implicit ctx: Context): Boolean = {
+      def widenNullary(tp: Type) = tp match {
+        case tp @ MethodType(Nil) => tp.resultType
         case _ => tp
       }
-      (this frozen_<:< that) || {
-        val rthat = result(that)
-        val rthis = result(this)
-        (rthat.ne(that) || rthis.ne(this)) && (rthis frozen_<:< rthat)
-      }
+      ((this.widenExpr frozen_<:< that.widenExpr) ||
+        matchLoosely && {
+          val this1 = widenNullary(this)
+          val that1 = widenNullary(that)
+          ((this1 `ne` this) || (that1 `ne` that)) && this1.overrides(this1, matchLoosely = false)
+        }
+      )
     }
 
     /** Is this type close enough to that type so that members

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

@@ -54,7 +54,7 @@ class ClassfileParser(
 
   def run()(implicit ctx: Context): Option[Embedded] = try {
     ctx.debuglog("[class] >> " + classRoot.fullName)
-    parseHeader
+    parseHeader()
     this.pool = new ConstantPool
     parseClass()
   } catch {
@@ -127,7 +127,7 @@ class ClassfileParser(
       // might be reassigned by later parseAttributes
       val staticInfo = TempClassInfoType(List(), staticScope, moduleRoot.symbol)
 
-      enterOwnInnerClasses
+      enterOwnInnerClasses()
 
       classRoot.setFlag(sflags)
       moduleRoot.setFlag(Flags.JavaDefined | Flags.ModuleClassCreationFlags)
@@ -185,7 +185,7 @@ class ClassfileParser(
     }
     // skip rest of member for now
     in.nextChar // info
-    skipAttributes
+    skipAttributes()
   }
 
   val memberCompleter = new LazyType {

compiler/src/dotty/tools/dotc/core/tasty/TastyReader.scala

@@ -62,12 +62,12 @@ class TastyReader(val bytes: Array[Byte], start: Int, end: Int, val base: Int =
   /** Read a natural number fitting in an Int in big endian format, base 128.
    *  All but the last digits have bit 0x80 set.
    */
-  def readNat(): Int = readLongNat.toInt
+  def readNat(): Int = readLongNat().toInt
 
   /** Read an integer number in 2's complement big endian format, base 128.
    *  All but the last digits have bit 0x80 set.
    */
-  def readInt(): Int = readLongInt.toInt
+  def readInt(): Int = readLongInt().toInt
 
   /** Read a natural number fitting in a Long in big endian format, base 128.
    *  All but the last digits have bit 0x80 set.

compiler/src/dotty/tools/dotc/parsing/JavaScanners.scala

@@ -435,7 +435,7 @@ object JavaScanners {
         nextChar()
       }
       if (ch == 'e' || ch == 'E') {
-        val lookahead = lookaheadReader
+        val lookahead = lookaheadReader()
         lookahead.nextChar()
         if (lookahead.ch == '+' || lookahead.ch == '-') {
           lookahead.nextChar()
@@ -475,7 +475,7 @@ object JavaScanners {
       }
       token = INTLIT
       if (base <= 10 && ch == '.') {
-        val lookahead = lookaheadReader
+        val lookahead = lookaheadReader()
         lookahead.nextChar()
         lookahead.ch match {
           case '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' |

compiler/src/dotty/tools/dotc/parsing/MarkupParserCommon.scala

@@ -36,7 +36,7 @@ private[dotty] trait MarkupParserCommon {
    */
   protected def xTag(pscope: NamespaceType): (String, AttributesType) = {
     val name = xName
-    xSpaceOpt
+    xSpaceOpt()
 
     (name, mkAttributes(name, pscope))
   }
@@ -47,7 +47,7 @@ private[dotty] trait MarkupParserCommon {
    */
   def xProcInstr: ElementType = {
     val n = xName
-    xSpaceOpt
+    xSpaceOpt()
     xTakeUntil(mkProcInstr(_, n, _), () => tmppos, "?>")
   }
 
@@ -75,7 +75,7 @@ private[dotty] trait MarkupParserCommon {
 
   private def takeUntilChar(it: Iterator[Char], end: Char): String = {
     val buf = new StringBuilder
-    while (it.hasNext) it.next match {
+    while (it.hasNext) it.next() match {
       case `end`  => return buf.toString
       case ch     => buf append ch
     }
@@ -89,7 +89,7 @@ private[dotty] trait MarkupParserCommon {
     if (xName != startName)
       errorNoEnd(startName)
 
-    xSpaceOpt
+    xSpaceOpt()
     xToken('>')
   }
 
@@ -136,9 +136,9 @@ private[dotty] trait MarkupParserCommon {
     val buf = new StringBuilder
     val it = attval.iterator.buffered
 
-    while (it.hasNext) buf append (it.next match {
+    while (it.hasNext) buf append (it.next() match {
       case ' ' | '\t' | '\n' | '\r' => " "
-      case '&' if it.head == '#'    => it.next ; xCharRef(it)
+      case '&' if it.head == '#'    => it.next() ; xCharRef(it)
       case '&'                      => attr_unescape(takeUntilChar(it, ';'))
       case c                        => c
     })
@@ -155,11 +155,11 @@ private[dotty] trait MarkupParserCommon {
     Utility.parseCharRef(ch, nextch, reportSyntaxError _, truncatedError _)
 
   def xCharRef(it: Iterator[Char]): String = {
-    var c = it.next
-    Utility.parseCharRef(() => c, () => { c = it.next }, reportSyntaxError _, truncatedError _)
+    var c = it.next()
+    Utility.parseCharRef(() => c, () => { c = it.next() }, reportSyntaxError _, truncatedError _)
   }
 
-  def xCharRef: String = xCharRef(() => ch, () => nextch)
+  def xCharRef: String = xCharRef(() => ch, nextch)
 
   /** Create a lookahead reader which does not influence the input */
   def lookahead(): BufferedIterator[Char]
@@ -192,20 +192,20 @@ private[dotty] trait MarkupParserCommon {
   }
 
   def xToken(that: Char): Unit = {
-    if (ch == that) nextch
+    if (ch == that) nextch()
     else xHandleError(that, "'%s' expected instead of '%s'".format(that, ch))
   }
   def xToken(that: Seq[Char]): Unit = { that foreach xToken }
 
   /** scan [S] '=' [S]*/
-  def xEQ() = { xSpaceOpt; xToken('='); xSpaceOpt }
+  def xEQ() = { xSpaceOpt(); xToken('='); xSpaceOpt() }
 
   /** skip optional space S? */
-  def xSpaceOpt() = while (isSpace(ch) && !eof) nextch
+  def xSpaceOpt() = while (isSpace(ch) && !eof) nextch()
 
   /** scan [3] S ::= (#x20 | #x9 | #xD | #xA)+ */
   def xSpace() =
-    if (isSpace(ch)) { nextch; xSpaceOpt }
+    if (isSpace(ch)) { nextch(); xSpaceOpt() }
     else xHandleError(ch, "whitespace expected")
 
   /** Apply a function and return the passed value */
@@ -238,7 +238,7 @@ private[dotty] trait MarkupParserCommon {
         truncatedError("")  // throws TruncatedXMLControl in compiler
 
       sb append ch
-      nextch
+      nextch()
     }
     unreachable
   }
@@ -251,7 +251,7 @@ private[dotty] trait MarkupParserCommon {
   private def peek(lookingFor: String): Boolean =
     (lookahead() take lookingFor.length sameElements lookingFor.iterator) && {
       // drop the chars from the real reader (all lookahead + orig)
-      (0 to lookingFor.length) foreach (_ => nextch)
+      (0 to lookingFor.length) foreach (_ => nextch())
       true
     }
 }