More lenient handling of mixed parameterless and nullary methods

When faced with a denotation that combines parameterless and nullary method
definitions (toString is a common example), ignore any redundant () applications.

1 files changed, 16 insertions, 0 deletions

diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index ed6b95c3b..3c318a6af 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -250,6 +250,22 @@ object ProtoTypes {
     /** Somebody called the `tupled` method of this prototype */
     def isTupled: Boolean = myTupled.isInstanceOf[FunProto]
 
+    /** If true, the application of this prototype was canceled. */
+    private var toDrop: Boolean = false
+
+    /** Cancel the application of this prototype. This can happen for a nullary
+     *  application `f()` if `f` refers to a symbol that exists both in parameterless
+     *  form `def f` and nullary method form `def f()`. A common example for such
+     *  a method is `toString`. If in that case the type in the denotation is
+     *  parameterless, we compensate by dropping the application.
+     */
+    def markAsDropped() = {
+      assert(args.isEmpty)
+      toDrop = true
+    }
+
+    def isDropped: Boolean = toDrop
+
     override def toString = s"FunProto(${args mkString ","} => $resultType)"
 
     def map(tm: TypeMap)(implicit ctx: Context): FunProto =