Define class elements in the correct order

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

@@ -413,24 +413,25 @@ export default function transformClass(
     const placement = node.static ? "static" : "instance";
     const methods = classState.methods[placement];
 
-    const { computed } = node;
-    if (computed) methods.hasComputed = true;
-
-    const key = t.toComputedKey(node);
     const descKey = node.kind === "method" ? "value" : node.kind;
+    const key =
+      t.isNumericLiteral(node.key) || t.isBigIntLiteral(node.key)
+        ? t.stringLiteral(String(node.key.value))
+        : t.toComputedKey(node);
 
     let fn = t.toExpression(node);
-    // infer function name
-    if (t.isStringLiteral(key) && node.kind === "method") {
-      fn = nameFunction({ id: key, node: node, scope });
+
+    if (t.isStringLiteral(key)) {
+      // infer function name
+      if (node.kind === "method") {
+        fn = nameFunction({ id: key, node: node, scope });
+      }
+    } else {
+      methods.hasComputed = true;
     }
 
     let descriptor;
-    if (
-      !methods.hasComputed &&
-      t.isStringLiteral(key) &&
-      methods.map.has(key.value)
-    ) {
+    if (!methods.hasComputed && methods.map.has(key.value)) {
       descriptor = methods.map.get(key.value);
       descriptor[descKey] = fn;
 

packages/babel-plugin-transform-classes/test/fixtures/get-set/numeric-keys/input.js

@@ -0,0 +1,17 @@
+class A {
+  get 1() {}
+  set [1](_) {}
+
+  get 2() {}
+  set "2"(_) {}
+
+  get 3n() {}
+  set 3(_) {}
+
+  get [4n]() {}
+  set "4"(_) {}
+
+  // Different keys
+  get 5n() {}
+  set "5n"(_) {}
+}

packages/babel-plugin-transform-classes/test/fixtures/get-set/numeric-keys/output.js

@@ -0,0 +1,40 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+let A = /*#__PURE__*/function () {
+  "use strict";
+
+  function A() {
+    _classCallCheck(this, A);
+  }
+
+  _createClass(A, [{
+    key: "1",
+    get: function () {},
+    set: function (_) {}
+  }, {
+    key: "2",
+    get: function () {},
+    set: function (_) {}
+  }, {
+    key: "3",
+    get: function () {},
+    set: function (_) {}
+  }, {
+    key: "4",
+    get: function () {},
+    set: function (_) {} // Different keys
+
+  }, {
+    key: "5",
+    get: function () {}
+  }, {
+    key: "5n",
+    set: function (_) {}
+  }]);
+
+  return A;
+}();