Fix #5336: Disallow overloads in refinements

Author: Duhemm

compiler/src/dotty/tools/dotc/reporting/diagnostic/ErrorMessageID.java

@@ -139,7 +139,8 @@ public enum ErrorMessageID {
     PureExpressionInStatementPositionID,
     TraitCompanionWithMutableStaticID,
     LazyStaticFieldID,
-    StaticOverridingNonStaticMembersID
+    StaticOverridingNonStaticMembersID,
+    OverloadInRefinementID
     ;
 
     public int errorNumber() {

compiler/src/dotty/tools/dotc/reporting/diagnostic/messages.scala

@@ -2170,4 +2170,13 @@ object messages {
     override def kind: String = "Syntax"
     override def explanation: String = ""
   }
+
+  case class OverloadInRefinement(rsym: Symbol)(implicit val ctx: Context)
+    extends Message(OverloadInRefinementID) {
+      override def msg: String = "Refinements cannot introduce overloaded definitions"
+      override def kind: String = "Overload"
+      override def explanation: String =
+        hl"""The refinement `$rsym` introduces an overloaded definition.
+            |Refinements cannot contain overloaded definitions.""".stripMargin
+    }
 }

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

@@ -1235,6 +1235,12 @@ class Typer extends Namer
       val rsym = refinement.symbol
       if (rsym.info.isInstanceOf[PolyType] && rsym.allOverriddenSymbols.isEmpty)
         ctx.error(PolymorphicMethodMissingTypeInParent(rsym, tpt1.symbol), refinement.pos)
+
+      // For some reason, `rsym.isOverloaded` always return false here.
+      val member = refineCls.info.member(rsym.name)
+      if (member.isOverloaded) {
+        ctx.error(OverloadInRefinement(rsym), refinement.pos)
+      }
     }
     assignType(cpy.RefinedTypeTree(tree)(tpt1, refinements1), tpt1, refinements1, refineCls)
   }

tests/neg/structural.scala

@@ -8,4 +8,6 @@ object Test3 {
 
   def h(x: { def f[T](a: T): Int }) = x.f[Int](4) // error: polymorphic refinement method ... no longer allowed
 
+  type A = { def foo(x: Int): Unit; def foo(x: String): Unit } // error: overloaded definition // error: overloaded definition
+  type B = { val foo: Int; def foo: Int } // error: duplicate foo
 }