{"body":"","parents":["7fddf42d060b1c2f75b895ae23744be27200b486"],"files":[{"path":"compiler\/forget\/src\/CompilerEntrypoint.ts","status":"A"},{"path":"compiler\/forget\/src\/CompilerInstrumentation.ts","status":"A"}],"commit":{"revision":"9077ac1f27008bf3d273c4873ca5edcca155ab05","shortRevision":"9077ac1f27","authorName":"Lauren Tan","authorEmail":"poteto@users.noreply.github.com","subject":"Copy files from src\/Babel to src\/","authoredAt":"2023-06-02T13:06:34-04:00"},"patch":"diff --git a\/compiler\/forget\/src\/CompilerEntrypoint.ts b\/compiler\/forget\/src\/CompilerEntrypoint.ts\nnew file mode 100644\nindex 0000000000..217a0ebebc\n--- \/dev\/null\n+++ b\/compiler\/forget\/src\/CompilerEntrypoint.ts\n@@ -0,0 +1,545 @@\n+\/**\n+ * Copyright (c) Meta Platforms, Inc. and affiliates.\n+ *\n+ * This source code is licensed under the MIT license found in the\n+ * LICENSE file in the root directory of this source tree.\n+ *\/\n+\n+import type * as BabelCore from \"@babel\/core\";\n+import jsx from \"@babel\/plugin-syntax-jsx\";\n+import * as t from \"@babel\/types\";\n+import {\n+ CompilerError,\n+ CompilerErrorDetail,\n+ ErrorSeverity,\n+} from \".\/CompilerError\";\n+import { compile } from \".\/CompilerPipeline\";\n+import { GeneratedSource } from \".\/HIR\";\n+import { addInstrumentForget } from \".\/CompilerInstrumentation\";\n+import {\n+ ExternalFunction,\n+ PluginOptions,\n+ parsePluginOptions,\n+} from \".\/Babel\/PluginOptions\";\n+\n+type BabelPluginPass = {\n+ opts: PluginOptions;\n+ filename: string | null;\n+};\n+\n+function hasUseForgetDirective(directive: t.Directive): boolean {\n+ return directive.value.value === \"use forget\";\n+}\n+\n+function hasAnyUseForgetDirectives(directives: t.Directive[]): boolean {\n+ for (const directive of directives) {\n+ if (hasUseForgetDirective(directive)) {\n+ return true;\n+ }\n+ }\n+ return false;\n+}\n+\n+\/**\n+ * The React Forget Babel Plugin\n+ * @param {*} _babel\n+ * @returns\n+ *\/\n+export default function ReactForgetBabelPlugin(\n+ _babel: typeof BabelCore\n+): BabelCore.PluginObj {\n+ let hasForgetCompiledCode: boolean = false;\n+\n+ function visitFn(\n+ fn: BabelCore.NodePath,\n+ pass: BabelPluginPass\n+ ): void {\n+ try {\n+ const compiled = compile(fn, pass.opts.environment);\n+ if (fn.node.id == null) {\n+ CompilerError.invariant(\n+ \"FunctionDeclaration must have a name\",\n+ fn.node.loc ?? GeneratedSource\n+ );\n+ }\n+ const originalIdent = fn.node.id;\n+\n+ if (pass.opts.gating != null) {\n+ \/\/ Rename existing function\n+ fn.node.id = addSuffix(fn.node.id, \"_uncompiled\");\n+\n+ \/\/ Rename and append compiled function\n+ if (compiled.id == null) {\n+ CompilerError.invariant(\n+ \"FunctionDeclaration must produce a name\",\n+ fn.node.loc ?? GeneratedSource\n+ );\n+ }\n+ compiled.id = addSuffix(compiled.id, \"_forget\");\n+ const compiledFn = fn.insertAfter(compiled)[0];\n+ compiledFn.skip();\n+\n+ \/\/ Build and append gating test\n+ compiledFn.insertAfter(\n+ buildGatingTest({\n+ originalFnDecl: fn,\n+ compiledIdent: compiled.id,\n+ originalIdent,\n+ gating: pass.opts.gating,\n+ })\n+ );\n+ if (pass.opts.instrumentForget != null) {\n+ const gatingIdentifierName =\n+ pass.opts.instrumentForget.gating.importSpecifierName;\n+ const instrumentFnName =\n+ pass.opts.instrumentForget.instrumentFn.importSpecifierName;\n+ addInstrumentForget(\n+ fn,\n+ originalIdent.name,\n+ gatingIdentifierName,\n+ instrumentFnName\n+ );\n+ addInstrumentForget(\n+ compiledFn,\n+ originalIdent.name,\n+ gatingIdentifierName,\n+ instrumentFnName\n+ );\n+ }\n+ } else {\n+ fn.replaceWith(compiled);\n+ if (pass.opts.instrumentForget != null) {\n+ const gatingIdentifierName =\n+ pass.opts.instrumentForget.gating.importSpecifierName;\n+ const instrumentFnName =\n+ pass.opts.instrumentForget.instrumentFn.importSpecifierName;\n+ addInstrumentForget(\n+ fn,\n+ originalIdent.name,\n+ gatingIdentifierName,\n+ instrumentFnName\n+ );\n+ }\n+ }\n+\n+ hasForgetCompiledCode = true;\n+ } catch (err) {\n+ if (pass.opts.logger && err) {\n+ pass.opts.logger.logEvent(\"err\", err);\n+ }\n+ \/** Always throw if the flag is enabled, otherwise we only throw if the error is critical\n+ * (eg an invariant is broken, meaning the compiler may be buggy). See\n+ * {@link CompilerError.isCritical} for mappings.\n+ * *\/\n+ if (\n+ pass.opts.panicOnBailout ||\n+ !(err instanceof CompilerError) ||\n+ (err instanceof CompilerError && err.isCritical())\n+ ) {\n+ throw err;\n+ } else {\n+ if (pass.opts.isDev) {\n+ log(err, pass.filename ?? null);\n+ }\n+ }\n+ } finally {\n+ \/\/ We are generating a new FunctionDeclaration node, so we must skip over it or this\n+ \/\/ traversal will loop infinitely.\n+ fn.skip();\n+ }\n+ }\n+\n+ const visitor = {\n+ FunctionDeclaration(\n+ fn: BabelCore.NodePath,\n+ pass: BabelPluginPass\n+ ): void {\n+ if (!shouldCompile(fn, pass)) {\n+ return;\n+ }\n+\n+ visitFn(fn, pass);\n+ },\n+\n+ ArrowFunctionExpression(\n+ fn: BabelCore.NodePath,\n+ pass: BabelPluginPass\n+ ): void {\n+ if (!shouldCompile(fn, pass)) {\n+ return;\n+ }\n+\n+ const loweredFn = buildFunctionDeclaration(fn);\n+ if (loweredFn instanceof CompilerError) {\n+ const error = loweredFn;\n+\n+ const options = parsePluginOptions(pass.opts);\n+ if (options.logger != null) {\n+ options.logger.logEvent(\"err\", error);\n+ }\n+\n+ if (options.panicOnBailout || error.isCritical()) {\n+ throw error;\n+ } else {\n+ if (pass.opts.isDev) {\n+ log(error, pass.filename);\n+ }\n+ }\n+ return;\n+ }\n+\n+ visitFn(loweredFn, pass);\n+ },\n+ };\n+\n+ return {\n+ name: \"react-forget\",\n+ inherits: jsx,\n+ visitor: {\n+ \/\/ Note: Babel does some \"smart\" merging of visitors across plugins, so even if A is inserted\n+ \/\/ prior to B, if A does not have a Program visitor and B does, B will run first. We always\n+ \/\/ want Forget to run true to source as possible.\n+ Program(path, pass): void {\n+ const options = parsePluginOptions(pass.opts);\n+\n+ const violations = [];\n+ const fileComments = pass.file.ast.comments;\n+ let fileHasUseForgetDirective = false;\n+ if (Array.isArray(fileComments)) {\n+ for (const comment of fileComments) {\n+ if (\n+ \/eslint-disable(-next-line)? react-hooks\\\/(exhaustive-deps|rules-of-hooks)\/.test(\n+ comment.value\n+ )\n+ ) {\n+ violations.push(comment);\n+ }\n+ }\n+ }\n+\n+ if (violations.length > 0) {\n+ path.traverse({\n+ Directive(path) {\n+ if (hasUseForgetDirective(path.node)) {\n+ fileHasUseForgetDirective = true;\n+ }\n+ },\n+ });\n+\n+ const reason = `One or more React eslint rules is disabled`;\n+ const error = new CompilerError();\n+ for (const violation of violations) {\n+ if (options.logger != null) {\n+ options.logger.logEvent(\"err\", {\n+ reason,\n+ filename: pass.filename,\n+ violation,\n+ });\n+ }\n+\n+ error.pushErrorDetail(\n+ new CompilerErrorDetail({\n+ reason,\n+ description: violation.value.trim(),\n+ severity: ErrorSeverity.UnsafeInput,\n+ codeframe: null,\n+ loc: violation.loc ?? null,\n+ })\n+ );\n+ }\n+\n+ if (fileHasUseForgetDirective) {\n+ if (options.panicOnBailout || error.isCritical()) {\n+ throw error;\n+ } else {\n+ if (options.isDev) {\n+ log(error, pass.filename ?? null);\n+ }\n+ }\n+ }\n+\n+ return;\n+ }\n+\n+ path.traverse(visitor, {\n+ ...pass,\n+ opts: { ...pass.opts, ...options },\n+ filename: pass.filename ?? null,\n+ });\n+\n+ \/\/ If there isn't already an import of * as React, insert it so useMemoCache doesn't\n+ \/\/ throw\n+ if (hasForgetCompiledCode) {\n+ let didInsertUseMemoCache = false;\n+ let hasExistingReactImport = false;\n+ path.traverse({\n+ CallExpression(callExprPath) {\n+ const callee = callExprPath.get(\"callee\");\n+ const args = callExprPath.get(\"arguments\");\n+ if (\n+ callee.isIdentifier() &&\n+ callee.node.name === \"useMemoCache\" &&\n+ args.length === 1 &&\n+ args[0].isNumericLiteral()\n+ ) {\n+ didInsertUseMemoCache = true;\n+ }\n+ },\n+ ImportDeclaration(importDeclPath) {\n+ if (isNonNamespacedImportOfReact(importDeclPath)) {\n+ hasExistingReactImport = true;\n+ }\n+ },\n+ });\n+ \/\/ If Forget did successfully compile inject\/update an import of\n+ \/\/ `import {unstable_useMemoCache as useMemoCache} from 'react'` and rename\n+ \/\/ `React.unstable_useMemoCache(n)` to `useMemoCache(n)`;\n+ if (didInsertUseMemoCache) {\n+ if (hasExistingReactImport) {\n+ let didUpdateImport = false;\n+ path.traverse({\n+ ImportDeclaration(importDeclPath) {\n+ if (isNonNamespacedImportOfReact(importDeclPath)) {\n+ importDeclPath.pushContainer(\n+ \"specifiers\",\n+ t.importSpecifier(\n+ t.identifier(\"useMemoCache\"),\n+ t.identifier(\"unstable_useMemoCache\")\n+ )\n+ );\n+ didUpdateImport = true;\n+ }\n+ },\n+ });\n+ if (didUpdateImport === false) {\n+ throw new Error(\n+ \"Expected an ImportDeclaration of react in order to update ImportSpecifiers with useMemoCache\"\n+ );\n+ }\n+ } else {\n+ path.unshiftContainer(\n+ \"body\",\n+ t.importDeclaration(\n+ [\n+ t.importSpecifier(\n+ t.identifier(\"useMemoCache\"),\n+ t.identifier(\"unstable_useMemoCache\")\n+ ),\n+ ],\n+ t.stringLiteral(\"react\")\n+ )\n+ );\n+ }\n+ }\n+ \/\/ TODO: check for duplicate import specifiers\n+ if (options.gating != null) {\n+ path.unshiftContainer(\n+ \"body\",\n+ buildImportForExternalFunction(options.gating)\n+ );\n+ }\n+ if (options.instrumentForget != null) {\n+ path.unshiftContainer(\n+ \"body\",\n+ buildImportForExternalFunction(options.instrumentForget.gating)\n+ );\n+ path.unshiftContainer(\n+ \"body\",\n+ buildImportForExternalFunction(\n+ options.instrumentForget.instrumentFn\n+ )\n+ );\n+ }\n+ }\n+ },\n+ },\n+ };\n+}\n+\n+function shouldCompile(\n+ fn: BabelCore.NodePath,\n+ pass: BabelPluginPass\n+): boolean {\n+ if (pass.opts.enableOnlyOnUseForgetDirective) {\n+ const body = fn.get(\"body\");\n+ if (!body.isBlockStatement()) {\n+ return false;\n+ }\n+ if (!hasAnyUseForgetDirectives(body.node.directives)) {\n+ return false;\n+ }\n+ }\n+\n+ if (fn.scope.getProgramParent() !== fn.scope.parent) {\n+ return false;\n+ }\n+\n+ return true;\n+}\n+\n+function log(error: CompilerError, filename: string | null): void {\n+ const filenameStr = filename ? `in ${filename}` : \"\";\n+ console.log(\n+ error.details\n+ .map(\n+ (e) =>\n+ `[ReactForget] Skipping compilation of component ${filenameStr}: ${e.printErrorMessage()}`\n+ )\n+ .join(\"\\n\")\n+ );\n+}\n+\n+function makeError(\n+ reason: string,\n+ loc: t.SourceLocation | null\n+): CompilerError {\n+ const error = new CompilerError();\n+ error.pushErrorDetail(\n+ new CompilerErrorDetail({\n+ reason,\n+ description: null,\n+ severity: ErrorSeverity.InvalidInput,\n+ codeframe: null,\n+ loc,\n+ })\n+ );\n+ return error;\n+}\n+\n+function buildFunctionDeclaration(\n+ fn: BabelCore.NodePath\n+): BabelCore.NodePath | CompilerError {\n+ if (!fn.parentPath.isVariableDeclarator()) {\n+ return makeError(\n+ \"ArrowFunctionExpression must be declared in variable declaration\",\n+ fn.node.loc ?? null\n+ );\n+ }\n+ const variableDeclarator = fn.parentPath;\n+\n+ if (!variableDeclarator.parentPath.isVariableDeclaration()) {\n+ return makeError(\n+ \"ArrowFunctionExpression must be a single declaration\",\n+ fn.node.loc ?? null\n+ );\n+ }\n+ const variableDeclaration = variableDeclarator.parentPath;\n+\n+ const id = variableDeclarator.get(\"id\");\n+ if (!id.isIdentifier()) {\n+ return makeError(\n+ \"ArrowFunctionExpression must have an id\",\n+ fn.node.loc ?? null\n+ );\n+ }\n+\n+ const rewrittenFn = variableDeclaration.replaceWith(\n+ t.functionDeclaration(\n+ id.node,\n+ fn.node.params,\n+ buildBlockStatement(fn),\n+ fn.node.generator,\n+ fn.node.async\n+ )\n+ )[0];\n+ fn.skip();\n+ return rewrittenFn;\n+}\n+\n+function buildBlockStatement(\n+ fn: BabelCore.NodePath\n+): t.BlockStatement {\n+ const body = fn.get(\"body\");\n+ if (body.isExpression()) {\n+ const wrappedBody = body.replaceWith(\n+ t.blockStatement([t.returnStatement(body.node)])\n+ )[0];\n+ body.skip();\n+\n+ return wrappedBody.node;\n+ }\n+\n+ if (!body.isBlockStatement()) {\n+ CompilerError.invariant(\n+ \"Body must be a BlockStatement\",\n+ body.node.loc ?? GeneratedSource\n+ );\n+ }\n+ return body.node;\n+}\n+\n+type GatingTestOptions = {\n+ originalFnDecl: BabelCore.NodePath;\n+ compiledIdent: t.Identifier;\n+ originalIdent: t.Identifier;\n+ gating: ExternalFunction;\n+};\n+function buildGatingTest({\n+ originalFnDecl,\n+ compiledIdent,\n+ originalIdent,\n+ gating,\n+}: GatingTestOptions): t.Node | t.Node[] {\n+ const testVarDecl = t.variableDeclaration(\"const\", [\n+ t.variableDeclarator(\n+ originalIdent,\n+ t.conditionalExpression(\n+ t.callExpression(buildSpecifierIdent(gating), []),\n+ compiledIdent,\n+ originalFnDecl.node.id!\n+ )\n+ ),\n+ ]);\n+\n+ \/\/ Re-export new declaration\n+ const parent = originalFnDecl.parentPath;\n+ if (t.isExportDefaultDeclaration(parent)) {\n+ \/\/ Re-add uncompiled function\n+ parent.replaceWith(originalFnDecl)[0].skip();\n+\n+ \/\/ Add test and synthesize new export\n+ return [testVarDecl, t.exportDefaultDeclaration(originalIdent)];\n+ } else if (t.isExportNamedDeclaration(parent)) {\n+ \/\/ Re-add uncompiled function\n+ parent.replaceWith(originalFnDecl)[0].skip();\n+\n+ \/\/ Add and export test\n+ return t.exportNamedDeclaration(testVarDecl);\n+ }\n+\n+ \/\/ Just add the test, no need for re-export\n+ return testVarDecl;\n+}\n+\n+function addSuffix(id: t.Identifier, suffix: string): t.Identifier {\n+ return t.identifier(`${id.name}${suffix}`);\n+}\n+\n+function buildImportForExternalFunction(\n+ gating: ExternalFunction\n+): t.ImportDeclaration {\n+ const specifierIdent = buildSpecifierIdent(gating);\n+ return t.importDeclaration(\n+ [t.importSpecifier(specifierIdent, specifierIdent)],\n+ t.stringLiteral(gating.source)\n+ );\n+}\n+\n+function buildSpecifierIdent(gating: ExternalFunction): t.Identifier {\n+ return t.identifier(gating.importSpecifierName);\n+}\n+\n+\/**\n+ * Matches `import { ... } from 'react';`\n+ * but not `import * as React from 'react';`\n+ *\/\n+function isNonNamespacedImportOfReact(\n+ importDeclPath: BabelCore.NodePath\n+): boolean {\n+ return (\n+ importDeclPath.get(\"source\").node.value === \"react\" &&\n+ importDeclPath\n+ .get(\"specifiers\")\n+ .every((specifier) => specifier.isImportSpecifier())\n+ );\n+}\ndiff --git a\/compiler\/forget\/src\/CompilerInstrumentation.ts b\/compiler\/forget\/src\/CompilerInstrumentation.ts\nnew file mode 100644\nindex 0000000000..2899ece583\n--- \/dev\/null\n+++ b\/compiler\/forget\/src\/CompilerInstrumentation.ts\n@@ -0,0 +1,33 @@\n+\/**\n+ * Copyright (c) Meta Platforms, Inc. and affiliates.\n+ *\n+ * This source code is licensed under the MIT license found in the\n+ * LICENSE file in the root directory of this source tree.\n+ *\/\n+\n+import { NodePath } from \"@babel\/core\";\n+import * as t from \"@babel\/types\";\n+\n+export function addInstrumentForget(\n+ fn: NodePath,\n+ fnName: string,\n+ gatingIdentifierName: string,\n+ instrumentFnName: string\n+): void {\n+ const fnBody = fn.get(\"body\");\n+ \/\/ Technically, this is a conditional hook call. However, we expect\n+ \/\/ __DEV__ and gatingIdentifier to be runtime constants\n+ const testExpr: t.Node = t.ifStatement(\n+ t.logicalExpression(\n+ \"&&\",\n+ t.identifier(\"__DEV__\"),\n+ t.identifier(gatingIdentifierName)\n+ ),\n+ t.expressionStatement(\n+ t.callExpression(t.identifier(instrumentFnName), [\n+ t.stringLiteral(fnName),\n+ ])\n+ )\n+ );\n+ fnBody.unshiftContainer(\"body\", testExpr);\n+}\n"}

dillon1000/react

Files changed