delay this assignment when referencing this inside an arrow function pre-bare super in derived class constructors - fixes #1920

src/babel/transformation/transformers/es6/classes/vanilla.js

@@ -52,7 +52,20 @@ var verifyConstructorVisitor = {
 
   ThisExpression(node, parent, scope, state) {
     if (state.isDerived && !state.hasBareSuper) {
-      throw this.errorWithNode("'this' is not allowed before super()");
+      if (this.inShadow()) {
+        var thisAlias = state.constructorPath.getData("this");
+
+        if (!thisAlias) {
+          thisAlias = state.constructorPath.setData(
+            "this",
+            state.constructorPath.scope.generateUidIdentifier("this")
+          );
+        }
+
+        return thisAlias;
+      } else {
+        throw this.errorWithNode("'this' is not allowed before super()");
+      }
     }
   },
 
@@ -429,13 +442,21 @@ export default class ClassTransformer {
 
    verifyConstructor(path: NodePath) {
     var state = {
-      hasBareSuper: false,
+      constructorPath: path.get("value"),
-      bareSuper:    null,
+      hasBareSuper:    false,
-      isDerived:     this.isDerived,
+      bareSuper:       null,
-      file:         this.file
+      isDerived:       this.isDerived,
+      file:            this.file,
     };
 
-    path.get("value").traverse(verifyConstructorVisitor, state);
+    state.constructorPath.traverse(verifyConstructorVisitor, state);
+
+    var thisAlias = state.constructorPath.getData("this");
+    if (thisAlias && state.bareSuper) {
+      state.bareSuper.insertAfter(t.variableDeclaration("var", [
+        t.variableDeclarator(thisAlias, t.thisExpression())
+      ]));
+    }
 
     this.bareSuper = state.bareSuper;
 

src/babel/transformation/transformers/internal/shadow-functions.js

@@ -6,7 +6,8 @@ export var metadata = {
 
 function remap(path, key, create) {
   // ensure that we're shadowed
-  if (!path.inShadow()) return;
+  var shadowPath = path.inShadow();
+  if (!shadowPath || shadowPath.isArrowFunctionExpression()) return;
 
   var shadowFunction = path.node._shadowedFunctionLiteral;
   var currentFunction;

src/babel/traversal/path/ancestry.js

@@ -178,7 +178,7 @@ export function inShadow() {
   var path = this;
   while (path) {
     if (path.isFunction()) {
-      if (path.node.shadow) {
+      if (path.node.shadow || path.isArrowFunctionExpression()) {
         return path;
       } else {
         return null;

test/core/fixtures/transformation/es6.classes/delay-arrow-function-for-bare-super-derived/actual.js

@@ -0,0 +1,7 @@
+class Foo extends Bar {
+  constructor() {
+    super(() => {
+      this.test;
+    });
+  }
+}

test/core/fixtures/transformation/es6.classes/delay-arrow-function-for-bare-super-derived/expected.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var Foo = (function (_Bar) {
+  function Foo() {
+    babelHelpers.classCallCheck(this, Foo);
+
+    babelHelpers.get(Object.getPrototypeOf(Foo.prototype), "constructor", this).call(this, function () {
+      _this.test;
+    });
+
+    var _this = this;
+  }
+
+  babelHelpers.inherits(Foo, _Bar);
+  return Foo;
+})(Bar);