Allow abstract members in native JS classes and traits.

With Scala.js-defined JS classes, it makes sense to have abstract members in native JS classes and traits, to force a Scala.js-defined JS class extending them to implement those members.
scala-js · gzm0 · Aug 24, 2015 · Jul 18, 2015 · Jul 20, 2015 · Jul 14, 2015
commit 29314b607340bae4ec3998ea1d5d88a45e5926ab
diff --git a/compiler/src/main/scala/org/scalajs/core/compiler/PrepJSInterop.scala b/compiler/src/main/scala/org/scalajs/core/compiler/PrepJSInterop.scala
@@ -582,15 +582,16 @@ abstract class PrepJSInterop extends plugins.PluginComponent
       }
 
       if (sym.isPrimaryConstructor || sym.isValueParameter ||
-          sym.isParamWithDefault || sym.isAccessor && !sym.isDeferred ||
-          sym.isParamAccessor || sym.isSynthetic ||
+          sym.isParamWithDefault || sym.isAccessor ||
+          sym.isParamAccessor || sym.isDeferred || sym.isSynthetic ||
           AllJSFunctionClasses.contains(sym.owner) ||
           (enclosingOwner is OwnerKind.JSClass)) {
         /* Ignore (i.e. allow) primary ctor, parameters, default parameter
-         * getters, accessors, param accessors, synthetic methods (to avoid
-         * double errors with case classes, e.g. generated copy method),
-         * js.Functions and js.ThisFunctions (they need abstract methods for
-         * SAM treatment), and any member of a Scala.js-defined class.
+         * getters, accessors, param accessors, abstract members, synthetic
+         * methods (to avoid double errors with case classes, e.g. generated
+         * copy method), js.Functions and js.ThisFunctions (they need abstract
+         * methods for SAM treatment), and any member of a Scala.js-defined
+         * JS class/trait.
          */
       } else if (jsPrimitives.isJavaScriptPrimitive(sym)) {
         // Force rhs of a primitive to be `sys.error("stub")` except for the

diff --git a/compiler/src/test/scala/org/scalajs/core/compiler/test/JSInteropTest.scala b/compiler/src/test/scala/org/scalajs/core/compiler/test/JSInteropTest.scala
@@ -250,20 +250,24 @@ class JSInteropTest extends DirectTest with TestHelpers {
       |                   ^
     """
 
+  }
+
+  @Test
+  def noWarnJSAnyDeferred: Unit = {
+
     """
-    trait A extends js.Object {
+    abstract class A extends js.Object {
       def value: Int
       val x: Int
     }
-    """ hasWarns
-    """
-      |newSource1.scala:4: warning: Members of traits, classes and objects extending js.Any may only contain members that call js.native. This will be enforced in 1.0.
-      |      def value: Int
-      |          ^
-      |newSource1.scala:5: warning: Members of traits, classes and objects extending js.Any may only contain members that call js.native. This will be enforced in 1.0.
-      |      val x: Int
-      |          ^
+    """.hasNoWarns
+
     """
+    trait A extends js.Object {
+      def value: Int
+      val x: Int
+    }
+    """.hasNoWarns
 
   }
 

diff --git a/test-suite/src/test/resources/ScalaJSDefinedTestNatives.js b/test-suite/src/test/resources/ScalaJSDefinedTestNatives.js
@@ -17,4 +17,17 @@
     }
   });
   $g.ScalaJSDefinedTestNativeParentClass = ScalaJSDefinedTestNativeParentClass;
+
+  /* Deferred members:
+   * val x: Int
+   * def bar(y: Int): Int
+   */
+  var ScalaJSDefinedTestNativeParentClassWithDeferred = function() {
+    $g.Object.call(this);
+  };
+  ScalaJSDefinedTestNativeParentClassWithDeferred.prototype.foo = function(y) {
+    return (this.bar((y + 4) | 0) + this.x) | 0;
+  };
+  $g.ScalaJSDefinedTestNativeParentClassWithDeferred =
+    ScalaJSDefinedTestNativeParentClassWithDeferred;
 }).call(this);
@@ -31,6 +31,18 @@ object ScalaJSDefinedTest extends JasmineTest {
     def bar: Int = x * 2
   }
 
+  trait NativeTraitWithDeferred extends js.Object {
+    val x: Int
+  }
+
+  // Defined in test-suite/src/test/resources/ScalaJSDefinedTestNatives.js
+  @JSName("ScalaJSDefinedTestNativeParentClassWithDeferred")
+  abstract class NativeParentClassWithDeferred extends NativeTraitWithDeferred {
+    def foo(y: Int): Int = js.native // = bar(y + 4) + x
+
+    def bar(y: Int): Int
+  }
+
   @ScalaJSDefined
   trait SimpleTrait extends js.Any {
     def foo(x: Int): Int
@@ -954,6 +966,33 @@ object ScalaJSDefinedTest extends JasmineTest {
       expect(foo.foobar(6)).toEqual(18)
     }
 
+    it("implement abstract members coming from a native JS class") {
+      @ScalaJSDefined
+      class ImplDeferredMembersFromJSParent
+          extends NativeParentClassWithDeferred {
+        val x: Int = 43
+
+        def bar(y: Int): Int = y * 2
+      }
+
+      val FooResult = (12 + 4) * 2 + 43
+
+      val foo = new ImplDeferredMembersFromJSParent
+      expect(foo.x).toEqual(43)
+      expect(foo.bar(32)).toEqual(64)
+      expect(foo.foo(12)).toEqual(FooResult)
+
+      val fooParent: NativeParentClassWithDeferred = foo
+      expect(fooParent.x).toEqual(43)
+      expect(fooParent.bar(32)).toEqual(64)
+      expect(fooParent.foo(12)).toEqual(FooResult)
+
+      val dyn = foo.asInstanceOf[js.Dynamic]
+      expect(dyn.x).toEqual(43)
+      expect(dyn.bar(32)).toEqual(64)
+      expect(dyn.foo(12)).toEqual(FooResult)
+    }
+
   }
 
   class SomeValueClass(val i: Int) extends AnyVal