feat: support ?.#x and ?.#m()

babel · May 22, 2020 · 785b6e8 · 785b6e8
1 parent 0742d99
commit 785b6e8
Show file tree

Hide file tree

Showing 33 changed files with 1,400 additions and 7 deletions.
diff --git a/packages/babel-helper-member-expression-to-functions/src/index.js b/packages/babel-helper-member-expression-to-functions/src/index.js
@@ -125,12 +125,6 @@ const handle = {
         throw member.buildCodeFrameError(`can't handle delete`);
       }
 
-      if (node.optional) {
-        throw member.buildCodeFrameError(
-          `can't handle '?.' directly before ${node.property.type}`,
-        );
-      }
-
       // Now, we're looking for the start of this optional chain, which is
       // optional to the left of this member.
       //
@@ -150,6 +144,8 @@ const handle = {
           startingOptional = startingOptional.get("callee");
           continue;
         }
+        // prevent infinite loop: unreachable if the AST is well-formed
+        throw new Error("Internal error");
       }
 
       const { scope } = member;
@@ -160,8 +156,13 @@ const handle = {
       const baseRef = scope.generateUidIdentifierBasedOnNode(startingNode);
       scope.push({ id: baseRef });
 
+      // Compute parentIsOptionalCall before `startingOptional` is replaced
+      // as `node` may refer to `startingOptional.node` before replaced.
+      const parentIsOptionalCall = parentPath.isOptionalCallExpression({
+        callee: node,
+      });
       startingOptional.replaceWith(toNonOptional(startingOptional, baseRef));
-      if (parentPath.isOptionalCallExpression({ callee: node })) {
+      if (parentIsOptionalCall) {
         parentPath.replaceWith(this.call(member, parent.arguments));
       } else {
         member.replaceWith(this.get(member));

diff --git a/...chain-private-call-with-transform/exec.js → ...before-member-call-with-transform/exec.js b/...chain-private-call-with-transform/exec.js → ...before-member-call-with-transform/exec.js
diff --git a/...hain-private-call-with-transform/input.js → ...efore-member-call-with-transform/input.js b/...hain-private-call-with-transform/input.js → ...efore-member-call-with-transform/input.js
diff --git a/...-private-call-with-transform/options.json → ...e-member-call-with-transform/options.json b/...-private-call-with-transform/options.json → ...e-member-call-with-transform/options.json
diff --git a/...ain-private-call-with-transform/output.js → ...fore-member-call-with-transform/output.js b/...ain-private-call-with-transform/output.js → ...fore-member-call-with-transform/output.js
diff --git a/...proposal-class-properties/test/fixtures/private/optional-chain-before-member-call/exec.js b/...proposal-class-properties/test/fixtures/private/optional-chain-before-member-call/exec.js
@@ -0,0 +1,122 @@
+class Foo {
+  static #x = 1;
+  static #m = function() { return this.#x; };
+  static #self = Foo;
+  static self = Foo;
+  static getSelf() { return this }
+
+  static test() {
+    const o = { Foo: Foo };
+    const deep = { very: { o } };
+    function fn() {
+      return o;
+    }
+    function fnDeep() {
+      return deep;
+    }
+
+    expect(o?.Foo.#m()).toEqual(1);
+    expect(o?.Foo.#m().toString).toEqual(1..toString);
+    expect(o?.Foo.#m().toString()).toEqual('1');
+
+    expect(deep?.very.o?.Foo.#m()).toEqual(1);
+    expect(deep?.very.o?.Foo.#m().toString).toEqual(1..toString);
+    expect(deep?.very.o?.Foo.#m().toString()).toEqual('1');
+
+    expect(o?.Foo.#self.#m()).toEqual(1);
+    expect(o?.Foo.#self.self.#m()).toEqual(1);
+    expect(o?.Foo.#self?.self.#m()).toEqual(1);
+    expect(o?.Foo.#self.self?.self.#m()).toEqual(1);
+    expect(o?.Foo.#self?.self?.self.#m()).toEqual(1);
+
+    expect(o?.Foo.#self.getSelf().#m()).toEqual(1);
+    expect(o?.Foo.#self.getSelf?.().#m()).toEqual(1);
+    expect(o?.Foo.#self?.getSelf().#m()).toEqual(1);
+    expect(o?.Foo.#self?.getSelf?.().#m()).toEqual(1);
+    expect(o?.Foo.#self.getSelf()?.self.#m()).toEqual(1);
+    expect(o?.Foo.#self.getSelf?.()?.self.#m()).toEqual(1);
+    expect(o?.Foo.#self?.getSelf()?.self.#m()).toEqual(1);
+    expect(o?.Foo.#self?.getSelf?.()?.self.#m()).toEqual(1);
+
+    expect(fn?.().Foo.#m()).toEqual(1);
+    expect(fn?.().Foo.#m().toString).toEqual(1..toString);
+    expect(fn?.().Foo.#m().toString()).toEqual('1');
+
+    expect(fnDeep?.().very.o?.Foo.#m()).toEqual(1);
+    expect(fnDeep?.().very.o?.Foo.#m().toString).toEqual(1..toString);
+    expect(fnDeep?.().very.o?.Foo.#m().toString()).toEqual('1');
+
+    expect(fn?.().Foo.#self.#m()).toEqual(1);
+    expect(fn?.().Foo.#self.self.#m()).toEqual(1);
+    expect(fn?.().Foo.#self?.self.#m()).toEqual(1);
+    expect(fn?.().Foo.#self.self?.self.#m()).toEqual(1);
+    expect(fn?.().Foo.#self?.self?.self.#m()).toEqual(1);
+
+    expect(fn?.().Foo.#self.getSelf().#m()).toEqual(1);
+    expect(fn?.().Foo.#self.getSelf?.().#m()).toEqual(1);
+    expect(fn?.().Foo.#self?.getSelf().#m()).toEqual(1);
+    expect(fn?.().Foo.#self?.getSelf?.().#m()).toEqual(1);
+    expect(fn?.().Foo.#self.getSelf()?.self.#m()).toEqual(1);
+    expect(fn?.().Foo.#self.getSelf?.()?.self.#m()).toEqual(1);
+    expect(fn?.().Foo.#self?.getSelf()?.self.#m()).toEqual(1);
+    expect(fn?.().Foo.#self?.getSelf?.()?.self.#m()).toEqual(1);
+  }
+
+  static testNull() {
+    const o = null;;
+    const deep = { very: { o } };
+    const fn = null;
+    function fnDeep() {
+      return deep;
+    }
+
+    expect(o?.Foo.#m()).toEqual(undefined);
+    expect(o?.Foo.#m().toString).toEqual(undefined);
+    expect(o?.Foo.#m().toString()).toEqual(undefined);
+
+    expect(deep?.very.o?.Foo.#m()).toEqual(undefined);
+    expect(deep?.very.o?.Foo.#m().toString).toEqual(undefined);
+    expect(deep?.very.o?.Foo.#m().toString()).toEqual(undefined);
+
+    expect(o?.Foo.#self.#m()).toEqual(undefined);
+    expect(o?.Foo.#self.self.#m()).toEqual(undefined);
+    expect(o?.Foo.#self?.self.#m()).toEqual(undefined);
+    expect(o?.Foo.#self.self?.self.#m()).toEqual(undefined);
+    expect(o?.Foo.#self?.self?.self.#m()).toEqual(undefined);
+
+    expect(o?.Foo.#self.getSelf().#m()).toEqual(undefined);
+    expect(o?.Foo.#self.getSelf?.().#m()).toEqual(undefined);
+    expect(o?.Foo.#self?.getSelf().#m()).toEqual(undefined);
+    expect(o?.Foo.#self?.getSelf?.().#m()).toEqual(undefined);
+    expect(o?.Foo.#self.getSelf()?.self.#m()).toEqual(undefined);
+    expect(o?.Foo.#self.getSelf?.()?.self.#m()).toEqual(undefined);
+    expect(o?.Foo.#self?.getSelf()?.self.#m()).toEqual(undefined);
+    expect(o?.Foo.#self?.getSelf?.()?.self.#m()).toEqual(undefined);
+
+    expect(fn?.().Foo.#m()).toEqual(undefined);
+    expect(fn?.().Foo.#m().toString).toEqual(undefined);
+    expect(fn?.().Foo.#m().toString()).toEqual(undefined);
+
+    expect(fnDeep?.().very.o?.Foo.#m()).toEqual(undefined);
+    expect(fnDeep?.().very.o?.Foo.#m().toString).toEqual(undefined);
+    expect(fnDeep?.().very.o?.Foo.#m().toString()).toEqual(undefined);
+
+    expect(fn?.().Foo.#self.#m()).toEqual(undefined);
+    expect(fn?.().Foo.#self.self.#m()).toEqual(undefined);
+    expect(fn?.().Foo.#self?.self.#m()).toEqual(undefined);
+    expect(fn?.().Foo.#self.self?.self.#m()).toEqual(undefined);
+    expect(fn?.().Foo.#self?.self?.self.#m()).toEqual(undefined);
+
+    expect(fn?.().Foo.#self.getSelf().#m()).toEqual(undefined);
+    expect(fn?.().Foo.#self.getSelf?.().#m()).toEqual(undefined);
+    expect(fn?.().Foo.#self?.getSelf().#m()).toEqual(undefined);
+    expect(fn?.().Foo.#self?.getSelf?.().#m()).toEqual(undefined);
+    expect(fn?.().Foo.#self.getSelf()?.self.#m()).toEqual(undefined);
+    expect(fn?.().Foo.#self.getSelf?.()?.self.#m()).toEqual(undefined);
+    expect(fn?.().Foo.#self?.getSelf()?.self.#m()).toEqual(undefined);
+    expect(fn?.().Foo.#self?.getSelf?.()?.self.#m()).toEqual(undefined);
+  }
+}
+
+Foo.test();
+Foo.testNull();
diff --git a/...vate/optional-chain-private-call/input.js → ...ptional-chain-before-member-call/input.js b/...vate/optional-chain-private-call/input.js → ...ptional-chain-before-member-call/input.js
diff --git a/.../optional-chain-private-call/options.json → ...nal-chain-before-member-call/options.json b/.../optional-chain-private-call/options.json → ...nal-chain-before-member-call/options.json
diff --git a/...ate/optional-chain-private-call/output.js → ...tional-chain-before-member-call/output.js b/...ate/optional-chain-private-call/output.js → ...tional-chain-before-member-call/output.js
diff --git a/...ate/optional-chain-with-transform/exec.js → ...in-before-property-with-transform/exec.js b/...ate/optional-chain-with-transform/exec.js → ...in-before-property-with-transform/exec.js
diff --git a/...te/optional-chain-with-transform/input.js → ...n-before-property-with-transform/input.js b/...te/optional-chain-with-transform/input.js → ...n-before-property-with-transform/input.js
diff --git a/...ptional-chain-with-transform/options.json → ...fore-property-with-transform/options.json b/...ptional-chain-with-transform/options.json → ...fore-property-with-transform/options.json
diff --git a/...e/optional-chain-with-transform/output.js → ...-before-property-with-transform/output.js b/...e/optional-chain-with-transform/output.js → ...-before-property-with-transform/output.js
diff --git a/...in-proposal-class-properties/test/fixtures/private/optional-chain-before-property/exec.js b/...in-proposal-class-properties/test/fixtures/private/optional-chain-before-property/exec.js
@@ -0,0 +1,121 @@
+class Foo {
+  static #x = 1;
+  static #self = Foo;
+  static self = Foo;
+  static getSelf() { return this }
+
+  static test() {
+    const o = { Foo: Foo };
+    const deep = { very: { o } };
+    function fn() {
+      return o;
+    }
+    function fnDeep() {
+      return deep;
+    }
+
+    expect(o?.Foo.#x).toEqual(1);
+    expect(o?.Foo.#x.toString).toEqual(1..toString);
+    expect(o?.Foo.#x.toString()).toEqual('1');
+
+    expect(deep?.very.o?.Foo.#x).toEqual(1);
+    expect(deep?.very.o?.Foo.#x.toString).toEqual(1..toString);
+    expect(deep?.very.o?.Foo.#x.toString()).toEqual('1');
+
+    expect(o?.Foo.#self.#x).toEqual(1);
+    expect(o?.Foo.#self.self.#x).toEqual(1);
+    expect(o?.Foo.#self?.self.#x).toEqual(1);
+    expect(o?.Foo.#self.self?.self.#x).toEqual(1);
+    expect(o?.Foo.#self?.self?.self.#x).toEqual(1);
+
+    expect(o?.Foo.#self.getSelf().#x).toEqual(1);
+    expect(o?.Foo.#self.getSelf?.().#x).toEqual(1);
+    expect(o?.Foo.#self?.getSelf().#x).toEqual(1);
+    expect(o?.Foo.#self?.getSelf?.().#x).toEqual(1);
+    expect(o?.Foo.#self.getSelf()?.self.#x).toEqual(1);
+    expect(o?.Foo.#self.getSelf?.()?.self.#x).toEqual(1);
+    expect(o?.Foo.#self?.getSelf()?.self.#x).toEqual(1);
+    expect(o?.Foo.#self?.getSelf?.()?.self.#x).toEqual(1);
+
+    expect(fn?.().Foo.#x).toEqual(1);
+    expect(fn?.().Foo.#x.toString).toEqual(1..toString);
+    expect(fn?.().Foo.#x.toString()).toEqual('1');
+
+    expect(fnDeep?.().very.o?.Foo.#x).toEqual(1);
+    expect(fnDeep?.().very.o?.Foo.#x.toString).toEqual(1..toString);
+    expect(fnDeep?.().very.o?.Foo.#x.toString()).toEqual('1');
+
+    expect(fn?.().Foo.#self.#x).toEqual(1);
+    expect(fn?.().Foo.#self.self.#x).toEqual(1);
+    expect(fn?.().Foo.#self?.self.#x).toEqual(1);
+    expect(fn?.().Foo.#self.self?.self.#x).toEqual(1);
+    expect(fn?.().Foo.#self?.self?.self.#x).toEqual(1);
+
+    expect(fn?.().Foo.#self.getSelf().#x).toEqual(1);
+    expect(fn?.().Foo.#self.getSelf?.().#x).toEqual(1);
+    expect(fn?.().Foo.#self?.getSelf().#x).toEqual(1);
+    expect(fn?.().Foo.#self?.getSelf?.().#x).toEqual(1);
+    expect(fn?.().Foo.#self.getSelf()?.self.#x).toEqual(1);
+    expect(fn?.().Foo.#self.getSelf?.()?.self.#x).toEqual(1);
+    expect(fn?.().Foo.#self?.getSelf()?.self.#x).toEqual(1);
+    expect(fn?.().Foo.#self?.getSelf?.()?.self.#x).toEqual(1);
+  }
+
+  static testNull() {
+    const o = null;;
+    const deep = { very: { o } };
+    const fn = null;
+    function fnDeep() {
+      return deep;
+    }
+
+    expect(o?.Foo.#x).toEqual(undefined);
+    expect(o?.Foo.#x.toString).toEqual(undefined);
+    expect(o?.Foo.#x.toString()).toEqual(undefined);
+
+    expect(deep?.very.o?.Foo.#x).toEqual(undefined);
+    expect(deep?.very.o?.Foo.#x.toString).toEqual(undefined);
+    expect(deep?.very.o?.Foo.#x.toString()).toEqual(undefined);
+
+    expect(o?.Foo.#self.#x).toEqual(undefined);
+    expect(o?.Foo.#self.self.#x).toEqual(undefined);
+    expect(o?.Foo.#self?.self.#x).toEqual(undefined);
+    expect(o?.Foo.#self.self?.self.#x).toEqual(undefined);
+    expect(o?.Foo.#self?.self?.self.#x).toEqual(undefined);
+
+    expect(o?.Foo.#self.getSelf().#x).toEqual(undefined);
+    expect(o?.Foo.#self.getSelf?.().#x).toEqual(undefined);
+    expect(o?.Foo.#self?.getSelf().#x).toEqual(undefined);
+    expect(o?.Foo.#self?.getSelf?.().#x).toEqual(undefined);
+    expect(o?.Foo.#self.getSelf()?.self.#x).toEqual(undefined);
+    expect(o?.Foo.#self.getSelf?.()?.self.#x).toEqual(undefined);
+    expect(o?.Foo.#self?.getSelf()?.self.#x).toEqual(undefined);
+    expect(o?.Foo.#self?.getSelf?.()?.self.#x).toEqual(undefined);
+
+    expect(fn?.().Foo.#x).toEqual(undefined);
+    expect(fn?.().Foo.#x.toString).toEqual(undefined);
+    expect(fn?.().Foo.#x.toString()).toEqual(undefined);
+
+    expect(fnDeep?.().very.o?.Foo.#x).toEqual(undefined);
+    expect(fnDeep?.().very.o?.Foo.#x.toString).toEqual(undefined);
+    expect(fnDeep?.().very.o?.Foo.#x.toString()).toEqual(undefined);
+
+    expect(fn?.().Foo.#self.#x).toEqual(undefined);
+    expect(fn?.().Foo.#self.self.#x).toEqual(undefined);
+    expect(fn?.().Foo.#self?.self.#x).toEqual(undefined);
+    expect(fn?.().Foo.#self.self?.self.#x).toEqual(undefined);
+    expect(fn?.().Foo.#self?.self?.self.#x).toEqual(undefined);
+
+    expect(fn?.().Foo.#self.getSelf().#x).toEqual(undefined);
+    expect(fn?.().Foo.#self.getSelf?.().#x).toEqual(undefined);
+    expect(fn?.().Foo.#self?.getSelf().#x).toEqual(undefined);
+    expect(fn?.().Foo.#self?.getSelf?.().#x).toEqual(undefined);
+    expect(fn?.().Foo.#self.getSelf()?.self.#x).toEqual(undefined);
+    expect(fn?.().Foo.#self.getSelf?.()?.self.#x).toEqual(undefined);
+    expect(fn?.().Foo.#self?.getSelf()?.self.#x).toEqual(undefined);
+    expect(fn?.().Foo.#self?.getSelf?.()?.self.#x).toEqual(undefined);
+  }
+}
+
+Foo.test();
+Foo.testNull();
diff --git a/.../fixtures/private/optional-chain/input.js → ...e/optional-chain-before-property/input.js b/.../fixtures/private/optional-chain/input.js → ...e/optional-chain-before-property/input.js
diff --git a/...tures/private/optional-chain/options.json → ...tional-chain-before-property/options.json b/...tures/private/optional-chain/options.json → ...tional-chain-before-property/options.json
diff --git a/...fixtures/private/optional-chain/output.js → .../optional-chain-before-property/output.js b/...fixtures/private/optional-chain/output.js → .../optional-chain-before-property/output.js