Implement superIsCallableConstructor

packages/babel-core/src/config/validation/options.js

@@ -350,6 +350,7 @@ export const assumptionsNames = new Set<string>([
   "setPublicClassFields",
   "setSpreadProperties",
   "skipForOfIteratorClosing",
+  "superIsCallableConstructor",
 ]);
 
 function getSource(loc: NestingPath): OptionsSource {

packages/babel-plugin-transform-classes/src/index.js

@@ -23,6 +23,8 @@ export default declare((api, options) => {
 
   const setClassMethods = api.assumption("setClassMethods") ?? options.loose;
   const constantSuper = api.assumption("constantSuper") ?? options.loose;
+  const superIsCallableConstructor =
+    api.assumption("superIsCallableConstructor") ?? options.loose;
 
   // todo: investigate traversal requeueing
   const VISITED = Symbol();
@@ -64,6 +66,7 @@ export default declare((api, options) => {
           transformClass(path, state.file, builtinClasses, loose, {
             setClassMethods,
             constantSuper,
+            superIsCallableConstructor,
           }),
         );
 

packages/babel-plugin-transform-classes/src/transformClass.js

@@ -12,7 +12,11 @@ import addCreateSuperHelper from "./inline-createSuper-helpers";
 
 type ReadonlySet<T> = Set<T> | { has(val: T): boolean };
 
-type ClassAssumptions = { setClassMethods: boolean, constantSuper: boolean };
+type ClassAssumptions = {
+  setClassMethods: boolean,
+  constantSuper: boolean,
+  superIsCallableConstructor: boolean,
+};
 
 function buildConstructor(classRef, constructorBody, node) {
   const func = t.functionDeclaration(
@@ -267,7 +271,7 @@ export default function transformClass(
     const bareSuperNode = bareSuper.node;
     let call;
 
-    if (classState.isLoose) {
+    if (assumptions.superIsCallableConstructor) {
       bareSuperNode.arguments.unshift(t.thisExpression());
       if (
         bareSuperNode.arguments.length === 2 &&
@@ -546,7 +550,7 @@ export default function transformClass(
     // Unshift to ensure that the constructor inheritance is set up before
     // any properties can be assigned to the prototype.
 
-    if (!classState.isLoose) {
+    if (!assumptions.superIsCallableConstructor) {
       classState.body.unshift(
         t.variableDeclaration("var", [
           t.variableDeclarator(

packages/babel-plugin-transform-classes/test/fixtures/assumption-superIsCallableConstructor/options.json

@@ -0,0 +1,12 @@
+{
+  "plugins": [
+    ["external-helpers", { "helperVersion": "7.100.0" }],
+    "transform-function-name",
+    "transform-classes",
+    ["transform-spread", { "loose": true }],
+    "transform-block-scoping"
+  ],
+  "assumptions": {
+    "superIsCallableConstructor": true
+  }
+}

packages/babel-plugin-transform-classes/test/fixtures/assumption-superIsCallableConstructor/super-class-id-member-expression/input.js

@@ -0,0 +1,7 @@
+class BaseController extends Chaplin.Controller {
+
+}
+
+class BaseController2 extends Chaplin.Controller.Another {
+
+}

packages/babel-plugin-transform-classes/test/fixtures/assumption-superIsCallableConstructor/super-class-id-member-expression/output.js

@@ -0,0 +1,25 @@
+var BaseController = /*#__PURE__*/function (_Chaplin$Controller) {
+  "use strict";
+
+  babelHelpers.inherits(BaseController, _Chaplin$Controller);
+
+  function BaseController() {
+    babelHelpers.classCallCheck(this, BaseController);
+    return _Chaplin$Controller.apply(this, arguments) || this;
+  }
+
+  return BaseController;
+}(Chaplin.Controller);
+
+var BaseController2 = /*#__PURE__*/function (_Chaplin$Controller$A) {
+  "use strict";
+
+  babelHelpers.inherits(BaseController2, _Chaplin$Controller$A);
+
+  function BaseController2() {
+    babelHelpers.classCallCheck(this, BaseController2);
+    return _Chaplin$Controller$A.apply(this, arguments) || this;
+  }
+
+  return BaseController2;
+}(Chaplin.Controller.Another);

packages/babel-plugin-transform-classes/test/fixtures/assumption-superIsCallableConstructor/super-class-this-usage/input.js

@@ -0,0 +1,9 @@
+class Test extends Foo {
+  constructor() {
+    super();
+
+    this;
+
+    this.prop = 1;
+  }
+}

packages/babel-plugin-transform-classes/test/fixtures/assumption-superIsCallableConstructor/super-class-this-usage/output.js

@@ -0,0 +1,17 @@
+var Test = /*#__PURE__*/function (_Foo) {
+  "use strict";
+
+  babelHelpers.inherits(Test, _Foo);
+
+  function Test() {
+    var _this;
+
+    babelHelpers.classCallCheck(this, Test);
+    _this = _Foo.call(this) || this;
+    babelHelpers.assertThisInitialized(_this);
+    _this.prop = 1;
+    return _this;
+  }
+
+  return Test;
+}(Foo);

packages/babel-plugin-transform-classes/test/fixtures/assumption-superIsCallableConstructor/super-class/input.js

@@ -0,0 +1 @@
+class Test extends Foo { }

packages/babel-plugin-transform-classes/test/fixtures/assumption-superIsCallableConstructor/super-class/output.js

@@ -0,0 +1,12 @@
+var Test = /*#__PURE__*/function (_Foo) {
+  "use strict";
+
+  babelHelpers.inherits(Test, _Foo);
+
+  function Test() {
+    babelHelpers.classCallCheck(this, Test);
+    return _Foo.apply(this, arguments) || this;
+  }
+
+  return Test;
+}(Foo);