Consider static and non-static methods as non-double def

compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala

@@ -793,6 +793,9 @@ class JSCodeGen()(using genCtx: Context) {
         name.name
     }.toSet
 
+    val staticNames = moduleClass.companionClass.info.allMembers
+      .collect { case d if d.name.isTermName && d.symbol.isScalaStatic => d.name }.toSet
+
     val members = {
       moduleClass.info.membersBasedOnFlags(required = Flags.Method,
           excluded = Flags.ExcludedForwarder).map(_.symbol)
@@ -815,6 +818,7 @@ class JSCodeGen()(using genCtx: Context) {
         || hasAccessBoundary
         || isOfJLObject
         || m.hasAnnotation(jsdefn.JSNativeAnnot) || isDefaultParamOfJSNativeDef // #4557
+        || staticNames(m.name)
     }
 
     val forwarders = for {
@@ -4769,7 +4773,7 @@ class JSCodeGen()(using genCtx: Context) {
   }
 
   private def isMethodStaticInIR(sym: Symbol): Boolean =
-    sym.is(JavaStatic)
+    sym.is(JavaStatic) || sym.isScalaStatic
 
   /** Generate a Class[_] value (e.g. coming from classOf[T]) */
   private def genClassConstant(tpe: Type)(implicit pos: Position): js.Tree =

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

@@ -1167,7 +1167,8 @@ trait Checking {
         def javaFieldMethodPair =
           decl.is(JavaDefined) && other.is(JavaDefined) &&
           decl.is(Method) != other.is(Method)
-        if (decl.matches(other) && !javaFieldMethodPair) {
+        def staticNonStaticPair = decl.isScalaStatic != other.isScalaStatic
+        if (decl.matches(other) && !javaFieldMethodPair && !staticNonStaticPair) {
           def doubleDefError(decl: Symbol, other: Symbol): Unit =
             if (!decl.info.isErroneous && !other.info.isErroneous)
               report.error(DoubleDefinition(decl, other, cls), decl.srcPos)

tests/run/19394.scala

@@ -0,0 +1,20 @@
+import scala.annotation.{ static, targetName }
+
+class Foo
+object Foo:
+  @static def foo: String = "foo"
+  @targetName("foo") def fooBincompat: String = foo
+
+class Bar
+object Bar:
+  @static def bar: String = "bar"
+  def bar: String = bar
+
+object Test:
+  def main(args: Array[String]): Unit =
+    assert(Foo.foo == "foo")
+    assert(Bar.bar == "bar")
+
+    import scala.reflect.Selectable.reflectiveSelectable
+    assert(Foo.asInstanceOf[{ def foo: String }].foo == "foo")
+    assert(Bar.asInstanceOf[{ def bar: String }].bar == "bar")