add class.hasInstance proposal (Stage 1) support

packages/babel-generator/src/generators/expressions.ts

@@ -359,3 +359,13 @@ export function ModuleExpression(node: t.ModuleExpression) {
     this.rightBrace();
   }
 }
+
+export function ClassHasInstanceExpression(node: t.ClassHasInstanceExpression) {
+  this.word("class");
+  this.token(".");
+  this.word("hasInstance");
+  this.printInnerComments(node);
+  this.token("(");
+  this.print(node.instance);
+  this.token(")");
+}

packages/babel-generator/test/fixtures/class-brand-check/input.js

@@ -0,0 +1,6 @@
+class Range {
+    equals(range) {
+        class.hasInstance(range);
+        class/* 1 */./* 2 */hasInstance/* 3 */(range);
+    }
+}

packages/babel-generator/test/fixtures/class-brand-check/options.json

@@ -0,0 +1,3 @@
+{
+  "plugins": ["proposal-class-brand-check","transform-runtime"]
+}

packages/babel-generator/test/fixtures/class-brand-check/output.js

@@ -0,0 +1,11 @@
+class Range {
+  equals(range) {
+      /* 1 */
+
+      /* 2 */
+
+      /* 3 */
+      class.hasInstance(range);
+      class.hasInstance(range);
+  }
+}

packages/babel-parser/ast/spec.md

@@ -88,6 +88,7 @@ These are the core @babel/parser (babylon) AST node types.
   - [ParenthesizedExpression](#parenthesizedexpression)
   - [DoExpression](#doexpression)
   - [ModuleExpression](#moduleexpression)
+  - [ClassHasInstanceExpression](#classhasinstanceexpression)
 - [Template Literals](#template-literals)
   - [TemplateLiteral](#templateliteral)
   - [TaggedTemplateExpression](#taggedtemplateexpression)

packages/babel-parser/src/parse-error/standard-errors.js

@@ -144,6 +144,9 @@ export default (_: typeof toParseErrorCredentials) => ({
   InvalidEscapedReservedWord: _<{| reservedWord: string |}>(
     ({ reservedWord }) => `Escape sequence in keyword ${reservedWord}.`,
   ),
+  InvalidHasinstanceParameter: _(
+    "'hasInstance' expression must have exactly one parameter.",
+  ),
   InvalidIdentifier: _<{| identifierName: string |}>(
     ({ identifierName }) => `Invalid identifier ${identifierName}.`,
   ),

packages/babel-parser/src/parser/expression.js

@@ -893,6 +893,42 @@ export default class ExpressionParser extends LValParser {
     return node;
   }
 
+  parseClassOrClassHasInstanceExpression<T: N.Class>(
+    node: T,
+    isStatement: boolean,
+  ): N.Class | N.ClassHasInstanceExpression {
+    this.next();
+    if (this.eat(tt.dot)) {
+      if (this.isContextual(tt._hasInstance)) {
+        this.expectPlugin("classBrandCheck");
+        return this.parseClassHasInstanceExpression(
+          node,
+          this.state.startPos,
+          this.state.startLoc,
+        );
+      } else {
+        throw this.raise(Errors.UnexpectedToken, { at: node });
+      }
+    }
+    this.takeDecorators(node);
+    return this.parseClass(node, isStatement);
+  }
+
+  parseClassHasInstanceExpression(base, startPos, startLoc) {
+    this.next(); // eat `hasinstance`
+    this.expect(tt.parenL);
+    const node = this.startNodeAt(startPos, startLoc);
+    const args = this.parseCallExpressionArguments(tt.parenR);
+    if (args.length !== 1 || args[0].type === "SpreadElement") {
+      throw this.raise(Errors.InvalidHasinstanceParameter, {
+        at: this.state.lastTokStartLoc,
+      });
+    }
+    node.instance = args[0];
+
+    return this.finishNode(node, "ClassHasInstanceExpression");
+  }
+
   toReferencedArguments(
     node: N.CallExpression | N.OptionalCallExpression,
     isParenthesizedExpr?: boolean,
@@ -1164,7 +1200,7 @@ export default class ExpressionParser extends LValParser {
       case tt._class:
         node = this.startNode();
         this.takeDecorators(node);
-        return this.parseClass(node, false);
+        return this.parseClassOrClassHasInstanceExpression(node, false);
 
       case tt._new:
         return this.parseNewOrNewTarget();

packages/babel-parser/src/parser/statement.js

@@ -367,7 +367,7 @@ export default class StatementParser extends ExpressionParser {
 
       case tt._class:
         if (context) this.unexpected();
-        return this.parseClass(node, true);
+        return this.parseClassOrClassHasInstanceExpression(node, true);
 
       case tt._if:
         return this.parseIfStatement(node);
@@ -1363,8 +1363,9 @@ export default class StatementParser extends ExpressionParser {
     isStatement: /* T === ClassDeclaration */ boolean,
     optionalId?: boolean,
   ): T {
-    this.next();
-    this.takeDecorators(node);
+    if (this.eat(tt._class)) {
+      this.takeDecorators(node);
+    }
 
     // A class definition is always strict mode code.
     const oldStrict = this.state.strict;

packages/babel-parser/src/plugins/placeholders.js

@@ -229,8 +229,10 @@ export default (superClass: Class<Parser>): Class<Parser> =>
     ): T {
       const type = isStatement ? "ClassDeclaration" : "ClassExpression";
 
-      this.next();
-      this.takeDecorators(node);
+      if (this.eat(tt._class)) {
+        this.takeDecorators(node);
+      }
+
       const oldStrict = this.state.strict;
 
       const placeholder = this.parsePlaceholder("Identifier");

packages/babel-parser/src/tokenizer/types.js

@@ -289,6 +289,7 @@ export const tt: { [name: string]: TokenType } = {
   _set: createKeywordLike("set", { startsExpr }),
   _static: createKeywordLike("static", { startsExpr }),
   _yield: createKeywordLike("yield", { startsExpr }),
+  _hasInstance: createKeywordLike("hasInstance", { startsExpr }),
 
   // Flow and TypeScript Keywordlike
   _asserts: createKeywordLike("asserts", { startsExpr }),

packages/babel-parser/src/types.js

@@ -702,6 +702,11 @@ export type ModuleExpression = NodeBase & {
   body: Program,
 };
 
+export type ClassHasInstanceExpression = NodeBase & {
+  type: "ClassHasInstanceExpression",
+  instance: Expression,
+};
+
 // Patterns
 
 // TypeScript access modifiers

packages/babel-parser/test/fixtures/experimental/_no-plugin/class-brand-check/input.js

@@ -0,0 +1,5 @@
+class Foo {
+    bar(obj) {
+        class.hasInstance(obj)
+    }
+}

packages/babel-parser/test/fixtures/experimental/_no-plugin/class-brand-check/options.json

@@ -0,0 +1,5 @@
+{
+  "throws": "This experimental syntax requires enabling the parser plugin: \"classBrandCheck\". (3:14)",
+  "plugins": []
+}
+

packages/babel-parser/test/fixtures/experimental/class-brand-check/invalid-arguments/input.js

@@ -0,0 +1,5 @@
+class Foo {
+    bar() {
+        class.hasInstance()
+    }
+}

packages/babel-parser/test/fixtures/experimental/class-brand-check/invalid-arguments/options.json

@@ -0,0 +1,5 @@
+{
+    "throws": "SyntaxError: 'hasInstance' expression must have exactly one parameter. (3:26)",
+    "plugins": ["classBrandCheck"]
+  }
+

packages/babel-parser/test/fixtures/experimental/class-brand-check/multiple-arguments-2/input.js

@@ -0,0 +1,5 @@
+class Foo {
+    bar(foo) {
+        class.hasInstance(...foo)
+    }
+}

packages/babel-parser/test/fixtures/experimental/class-brand-check/multiple-arguments-2/options.json

@@ -0,0 +1,5 @@
+{
+    "throws": "SyntaxError: 'hasInstance' expression must have exactly one parameter. (3:32)",
+    "plugins": ["classBrandCheck"]
+  }
+

packages/babel-parser/test/fixtures/experimental/class-brand-check/multiple-arguments-3/input.js

@@ -0,0 +1,5 @@
+class Foo {
+    bar(foo,bar) {
+        class.hasInstance(foo,...bar)
+    }
+}

packages/babel-parser/test/fixtures/experimental/class-brand-check/multiple-arguments-3/options.json

@@ -0,0 +1,5 @@
+{
+    "throws": "SyntaxError: 'hasInstance' expression must have exactly one parameter. (3:36)",
+    "plugins": ["classBrandCheck"]
+  }
+

packages/babel-parser/test/fixtures/experimental/class-brand-check/multiple-arguments/input.js

@@ -0,0 +1,5 @@
+class Foo {
+    bar(foo,bar) {
+        class.hasInstance(foo,bar)
+    }
+}

packages/babel-parser/test/fixtures/experimental/class-brand-check/multiple-arguments/options.json

@@ -0,0 +1,5 @@
+{
+    "throws": "SyntaxError: 'hasInstance' expression must have exactly one parameter. (3:33)",
+    "plugins": ["classBrandCheck"]
+  }
+

packages/babel-parser/typings/babel-parser.d.ts

@@ -124,6 +124,7 @@ export type ParserPlugin =
   | "bigInt"
   | "classPrivateMethods"
   | "classPrivateProperties"
+  | "classBrandCheck"
   | "classProperties"
   | "classStaticBlock" // Enabled by default
   | "decimal"

packages/babel-plugin-proposal-class-brand-check/.gitignore

@@ -0,0 +1 @@
+temp/

packages/babel-plugin-proposal-class-brand-check/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@babel/plugin-proposal-class-brand-check",
+  "version": "7.16.0",
+  "description": "",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-plugin-proposal-class-brand-check"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./package.json": "./package.json"
+  },
+  "keywords": [
+    "babel-plugin"
+  ],
+  "dependencies": {
+    "@babel/helper-plugin-test-runner": "workspace:^",
+    "@babel/helper-plugin-utils": "workspace:^",
+    "@babel/parser": "workspace:^",
+    "@babel/traverse": "workspace:^",
+    "@babel/types": "workspace:^"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.0.0-0"
+  },
+  "conditions": {
+    "BABEL_8_BREAKING": [
+      null,
+      {
+        "exports": null
+      }
+    ]
+  },
+  "engines": {
+    "node": ">=13.0.0"
+  },
+  "author": "The Babel Team (https://babel.dev/team)"
+}

packages/babel-plugin-proposal-class-brand-check/src/index.js

@@ -0,0 +1,100 @@
+import { declare } from "@babel/helper-plugin-utils";
+import * as t from "@babel/types";
+export default declare(api => {
+  api.assertVersion(7);
+
+  return {
+    name: "proposal-class-brand-check",
+    manipulateOptions(opts, parserOpts) {
+      parserOpts.plugins.push("classBrandCheck");
+    },
+    visitor: {
+      ClassHasInstanceExpression(path) {
+        const key = "set";
+        const node = path.node;
+        const instanceItem = node.instance;
+        if (!instanceItem) {
+          throw new Error("Expected 1 arguments, but got " + instanceItem);
+        }
+        let setID = path.scope.generateUidIdentifier(key);
+        path.findParent(path => {
+          if (path.type === "ClassDeclaration") {
+            // unique map
+            const uniqueID = path.scope.parent.globals[key];
+            if (uniqueID) {
+              setID = uniqueID;
+            } else {
+              const id = t.identifier(setID.name);
+              const weakSet = t.identifier("WeakSet");
+              const expression = t.newExpression(weakSet, []);
+              const declarator = t.variableDeclarator(id, expression);
+              path.insertBefore(t.variableDeclaration("var", [declarator]));
+              path.scope.parent.globals[key] = setID;
+
+              const body = path.node.body;
+              if (body.type === "ClassBody") {
+                const bodyList = body.body;
+                const consFlag = bodyList.some(
+                  node => node.kind === "constructor",
+                );
+                if (!consFlag) {
+                  const key = "constructor";
+                  const body = t.blockStatement([], []);
+                  const constructorMethod = t.classMethod(
+                    key,
+                    t.identifier(key),
+                    [],
+                    body,
+                    false,
+                    false,
+                    false,
+                    false,
+                  );
+                  bodyList.unshift(constructorMethod);
+                }
+
+                bodyList.forEach(node => {
+                  if (node.kind === "constructor") {
+                    const consBody = node.body;
+                    const expressionList = consBody.body;
+
+                    const memberExpression = t.memberExpression(
+                      t.identifier(setID.name),
+                      t.identifier("add"),
+                      false,
+                    );
+
+                    const callExpression = t.callExpression(memberExpression, [
+                      t.thisExpression(),
+                    ]);
+                    const addExpression = t.expressionStatement(callExpression);
+
+                    const returnFlag = expressionList.findIndex(
+                      expression => expression.type === "ReturnStatement",
+                    );
+                    if (returnFlag === -1) {
+                      expressionList.push(addExpression);
+                    } else if (returnFlag === 0) {
+                      expressionList.unshift(addExpression);
+                    } else {
+                      expressionList.splice(returnFlag, 0, addExpression);
+                    }
+                  }
+                });
+              }
+            }
+          }
+        });
+        const memberExpression = t.memberExpression(
+          t.identifier(setID.name),
+          t.identifier("has"),
+          false,
+        );
+        const callExpression = t.callExpression(memberExpression, [
+          instanceItem,
+        ]);
+        path.replaceWith(callExpression);
+      },
+    },
+  };
+});