feat: Implement privateFieldsAsSymbols assumption for classes

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

@@ -277,6 +277,7 @@ const knownAssumptions = [
   "noIncompleteNsImportDetection",
   "noNewArrows",
   "objectRestNoSymbols",
+  "privateFieldsAsSymbols",
   "privateFieldsAsProperties",
   "pureGetters",
   "setClassMethods",

packages/babel-helper-create-class-features-plugin/src/fields.ts

@@ -58,6 +58,7 @@ export function buildPrivateNamesMap(props: PropPath[]) {
 export function buildPrivateNamesNodes(
   privateNamesMap: PrivateNamesMap,
   privateFieldsAsProperties: boolean,
+  privateFieldsAsSymbols: boolean,
   state: File,
 ) {
   const initNodes: t.Statement[] = [];
@@ -67,6 +68,9 @@ export function buildPrivateNamesNodes(
     // both static and instance fields are transpiled using a
     // secret non-enumerable property. Hence, we also need to generate that
     // key (using the classPrivateFieldLooseKey helper).
+    // When the privateFieldsAsSymbols assumption is enabled,
+    // both static and instance fields are transpiled using a
+    // secret Symbol to define a non-enumerable property.
     // In spec mode, only instance fields need a "private name" initializer
     // because static fields are directly assigned to a variable in the
     // buildPrivateStaticFieldInitSpec function.
@@ -80,15 +84,18 @@ export function buildPrivateNamesNodes(
       init = t.callExpression(state.addHelper("classPrivateFieldLooseKey"), [
         t.stringLiteral(name),
       ]);
+      annotateAsPure(init);
+    } else if (privateFieldsAsSymbols) {
+      init = t.callExpression(t.identifier("Symbol"), [t.stringLiteral(name)]);
     } else if (!isStatic) {
       init = t.newExpression(
         t.identifier(!isMethod || isAccessor ? "WeakMap" : "WeakSet"),
         [],
       );
+      annotateAsPure(init);
     }
 
     if (init) {
-      annotateAsPure(init);
       initNodes.push(template.statement.ast`var ${id} = ${init}`);
     }
   }

packages/babel-helper-create-class-features-plugin/src/index.ts

@@ -1,5 +1,6 @@
 import { types as t } from "@babel/core";
 import type { PluginAPI, PluginObject } from "@babel/core";
+import type { AssumptionName } from "@babel/core/src/config/validation/options";
 import type { NodePath } from "@babel/traverse";
 import nameFunction from "@babel/helper-function-name";
 import splitExportDeclaration from "@babel/helper-split-export-declaration";
@@ -48,30 +49,38 @@ export function createClassFeaturePlugin({
   inherits,
 }: Options): PluginObject {
   const setPublicClassFields = api.assumption("setPublicClassFields");
+  const privateFieldsAsSymbols = api.assumption("privateFieldsAsSymbols");
   const privateFieldsAsProperties = api.assumption("privateFieldsAsProperties");
+  const privateFieldsAsSymbolsOrProperties =
+    privateFieldsAsProperties || privateFieldsAsSymbols;
   const constantSuper = api.assumption("constantSuper");
   const noDocumentAll = api.assumption("noDocumentAll");
 
   if (loose === true) {
-    const explicit = [];
+    const explicit: AssumptionName[] = [];
 
     if (setPublicClassFields !== undefined) {
-      explicit.push(`"setPublicClassFields"`);
+      explicit.push("setPublicClassFields");
     }
     if (privateFieldsAsProperties !== undefined) {
-      explicit.push(`"privateFieldsAsProperties"`);
+      explicit.push("privateFieldsAsProperties");
+    }
+    if (privateFieldsAsSymbols !== undefined) {
+      explicit.push("privateFieldsAsSymbols");
     }
     if (explicit.length !== 0) {
       console.warn(
         `[${name}]: You are using the "loose: true" option and you are` +
-          ` explicitly setting a value for the ${explicit.join(" and ")}` +
+          ` explicitly setting a value for the ${explicit
+            .map(assumptionName => `"${assumptionName}"`)
+            .join(" and ")}` +
           ` assumption${explicit.length > 1 ? "s" : ""}. The "loose" option` +
           ` can cause incompatibilities with the other class features` +
           ` plugins, so it's recommended that you replace it with the` +
           ` following top-level option:\n` +
           `\t"assumptions": {\n` +
           `\t\t"setPublicClassFields": true,\n` +
-          `\t\t"privateFieldsAsProperties": true\n` +
+          `\t\t"privateFieldsAsSymbols": true\n` +
           `\t}`,
       );
     }
@@ -191,6 +200,7 @@ export function createClassFeaturePlugin({
         const privateNamesNodes = buildPrivateNamesNodes(
           privateNamesMap,
           privateFieldsAsProperties ?? loose,
+          privateFieldsAsSymbols ?? false,
           file,
         );
 
@@ -199,7 +209,8 @@ export function createClassFeaturePlugin({
           path,
           privateNamesMap,
           {
-            privateFieldsAsProperties: privateFieldsAsProperties ?? loose,
+            privateFieldsAsProperties:
+              privateFieldsAsSymbolsOrProperties ?? loose,
             noDocumentAll,
             innerBinding,
           },
@@ -231,7 +242,7 @@ export function createClassFeaturePlugin({
                 privateNamesMap,
                 file,
                 setPublicClassFields ?? loose,
-                privateFieldsAsProperties ?? loose,
+                privateFieldsAsSymbolsOrProperties ?? loose,
                 constantSuper ?? loose,
                 innerBinding,
               ));
@@ -246,7 +257,7 @@ export function createClassFeaturePlugin({
               privateNamesMap,
               file,
               setPublicClassFields ?? loose,
-              privateFieldsAsProperties ?? loose,
+              privateFieldsAsSymbolsOrProperties ?? loose,
               constantSuper ?? loose,
               innerBinding,
             ));

packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-class-properties/warn-loose-and-assumptions/stderr.txt

@@ -1,5 +1,5 @@
 [proposal-class-properties]: You are using the "loose: true" option and you are explicitly setting a value for the "setPublicClassFields" assumption. The "loose" option can cause incompatibilities with the other class features plugins, so it's recommended that you replace it with the following top-level option:
 	"assumptions": {
 		"setPublicClassFields": true,
-		"privateFieldsAsProperties": true
+		"privateFieldsAsSymbols": true
 	}

packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-private-methods/privateFieldsAsSymbols-true/input.js

@@ -0,0 +1,5 @@
+class X {
+  #privateMethod() {
+    return 42;
+  }
+}

packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-private-methods/privateFieldsAsSymbols-true/options.json

@@ -0,0 +1,7 @@
+{
+  "plugins": [["proposal-private-methods", { "loose": false }]],
+  "assumptions": {
+    "setPublicClassFields": true,
+    "privateFieldsAsSymbols": true
+  }
+}

packages/babel-helper-create-class-features-plugin/test/fixtures/plugin-proposal-private-methods/privateFieldsAsSymbols-true/output.js

@@ -0,0 +1,11 @@
+var _privateMethod = Symbol("privateMethod");
+class X {
+  constructor() {
+    Object.defineProperty(this, _privateMethod, {
+      value: _privateMethod2
+    });
+  }
+}
+function _privateMethod2() {
+  return 42;
+}

packages/babel-plugin-proposal-class-properties/test/fixtures/assumption-setPublicClassFields/static-super-loose/stderr.txt

@@ -1,5 +1,5 @@
 [proposal-class-properties]: You are using the "loose: true" option and you are explicitly setting a value for the "setPublicClassFields" assumption. The "loose" option can cause incompatibilities with the other class features plugins, so it's recommended that you replace it with the following top-level option:
 	"assumptions": {
 		"setPublicClassFields": true,
-		"privateFieldsAsProperties": true
+		"privateFieldsAsSymbols": true
 	}