flow-upgrade 1.1.0 → 2.0.0

package/dist/codemods/removeDuplicateClassProperties.js

@@ -0,0 +1,268 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _getClassMemberName = require("../codemodUtils/getClassMemberName");
+
+var _replaceMethodWithArrowProp = require("../codemodUtils/replaceMethodWithArrowProp");
+
+var _Types = require("../Types");
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * 
+ */
+function getKind(member) {
+  switch (member.type) {
+    case 'MethodDefinition':
+      switch (member.kind) {
+        case 'get':
+          return 'Getter';
+
+        case 'set':
+          return 'Setter';
+
+        case 'method':
+        case 'constructor':
+          return 'Method';
+      }
+
+      throw new Error(`Unexpected method kind: ${member.kind}`);
+
+    case 'PropertyDefinition':
+      return 'Property';
+  }
+
+  throw new Error(`Unexpected member type: ${member.type}`);
+}
+
+function findDuplicates(membersMap) {
+  const toDelete = [];
+
+  for (const [, members] of membersMap) {
+    if (members.length === 1) {
+      continue;
+    }
+
+    let lastMember = null;
+
+    for (const member of members) {
+      const kind = getKind(member);
+
+      if (lastMember == null) {
+        lastMember = {
+          kind,
+          member
+        };
+        continue;
+      } // handle the valid cases
+
+
+      switch (lastMember.kind) {
+        case 'GetterSetter':
+          if (kind === 'Getter') {
+            const oldGetter = lastMember.getter;
+            lastMember.getter = member;
+            toDelete.push(oldGetter);
+            continue;
+          } else if (kind === 'Setter') {
+            const oldSetter = lastMember.setter;
+            lastMember.setter = member;
+            toDelete.push(oldSetter);
+            continue;
+          }
+
+          break;
+
+        case 'Getter':
+          if (kind === 'Setter') {
+            lastMember = {
+              kind: 'GetterSetter',
+              getter: lastMember.member,
+              setter: member
+            };
+            continue;
+          }
+
+          break;
+
+        case 'Setter':
+          if (kind === 'Getter') {
+            lastMember = {
+              kind: 'GetterSetter',
+              getter: member,
+              setter: lastMember.member
+            };
+            continue;
+          }
+
+          break;
+      } // overwrite and delete the old member as it's incompatible
+
+
+      if (lastMember.kind === 'GetterSetter') {
+        toDelete.push(lastMember.getter);
+        toDelete.push(lastMember.setter);
+      } else {
+        toDelete.push(lastMember.member);
+      }
+
+      lastMember = {
+        kind,
+        member
+      };
+    }
+  }
+
+  return toDelete;
+}
+
+var _default = (0, _Types.codemod)({
+  title: 'Remove Duplicate Class Properties',
+  description: 'Removes useless duplicate class properties and fixes bad constructor binding in those classes',
+  transform: context => {
+    let classStack = null;
+    return {
+      // find and delete duplicated members
+      'ClassDeclaration, ClassExpression'(node) {
+        const staticMembers = new Map();
+        const instanceMembers = new Map();
+
+        for (const member of node.body.body) {
+          const membersMap = member.static ? staticMembers : instanceMembers;
+          const name = (0, _getClassMemberName.getClassMemberName)(member);
+
+          if (name == null) {
+            // unsupported computed member
+            continue;
+          }
+
+          const existingMember = membersMap.get(name);
+
+          if (existingMember == null) {
+            membersMap.set(name, [member]);
+          } else {
+            existingMember.push(member);
+          }
+        }
+
+        const toDelete = new Set(findDuplicates(staticMembers).concat(findDuplicates(instanceMembers)));
+
+        if (toDelete.size === 0) {
+          return;
+        } // mark members for deletion
+
+
+        for (const memberToDelete of toDelete) {
+          var _memberToDelete$value;
+
+          if (memberToDelete.type === 'PropertyDefinition' && ((_memberToDelete$value = memberToDelete.value) === null || _memberToDelete$value === void 0 ? void 0 : _memberToDelete$value.type) === 'CallExpression') {
+            console.log(context.buildCodeFrame(memberToDelete.value, 'Deleted a property with a CallExpression value. You should double check this was safe.'));
+          }
+
+          context.removeNode(memberToDelete);
+        } // we need the final list of instance members so we can
+        // fix up rebinding later
+
+
+        const newInstanceMembers = new Map();
+
+        for (const member of node.body.body) {
+          if (toDelete.has(member)) {
+            continue;
+          }
+
+          if (member.static) {
+            continue;
+          }
+
+          const name = (0, _getClassMemberName.getClassMemberName)(member);
+
+          if (name == null) {
+            continue;
+          }
+
+          const kind = getKind(member);
+          newInstanceMembers.set(name, {
+            kind,
+            member
+          });
+        } // push the stack
+
+
+        classStack = {
+          current: node,
+          instanceMembers: newInstanceMembers,
+          parent: classStack
+        };
+      },
+
+      // remove unnecessary .bind in constructor
+      'MethodDefinition[kind = "constructor"] ExpressionStatement > AssignmentExpression[operator = "="] > MemberExpression[object.type = "ThisExpression"].left'(node) {
+        if (!classStack) {
+          return;
+        }
+
+        const instanceMembers = classStack.instanceMembers;
+
+        if (node.property.type !== 'Identifier') {
+          return;
+        }
+
+        const subjectName = node.property.name;
+        const member = instanceMembers.get(subjectName); // the subject member must be a method
+
+        if ((member === null || member === void 0 ? void 0 : member.kind) !== 'Method') {
+          return;
+        }
+
+        const assignmentExpr = node.parent;
+        const exprStatement = assignmentExpr.parent;
+
+        if (assignmentExpr.type !== 'AssignmentExpression' || exprStatement.type !== 'ExpressionStatement') {
+          throw new Error('this cannot happen');
+        }
+
+        const right = assignmentExpr.right; // we're looking for `this.thing = this.thing.bind(this)`
+
+        if (right.type !== 'CallExpression' || right.arguments.length !== 1 || right.arguments[0].type !== 'ThisExpression' || right.callee.type !== 'MemberExpression' || right.callee.computed || right.callee.property.type !== 'Identifier' || right.callee.property.name !== 'bind' || right.callee.object.type !== 'MemberExpression' || right.callee.object.computed || right.callee.object.object.type !== 'ThisExpression' || right.callee.object.property.type !== 'Identifier' || right.callee.object.property.name !== subjectName) {
+          console.log(context.buildCodeFrame(right, `${subjectName} was reassigned, but not to a bind. You can probably manually correct this.`));
+          return;
+        } // remove the bind assignment and...
+
+
+        context.removeStatement(exprStatement);
+        const method = member.member;
+
+        if (method.type !== 'MethodDefinition') {
+          throw new Error('this cannot happen');
+        } // convert the method to an arrow function
+
+
+        (0, _replaceMethodWithArrowProp.replaceMethodWithArrowProp)(context, method, subjectName);
+      },
+
+      // pop the stack
+      'ClassDeclaration, ClassExpression:exit'(node) {
+        var _classStack;
+
+        if (classStack && ((_classStack = classStack) === null || _classStack === void 0 ? void 0 : _classStack.current) === node) {
+          var _classStack2;
+
+          classStack = (_classStack2 = classStack) === null || _classStack2 === void 0 ? void 0 : _classStack2.parent;
+        }
+      }
+
+    };
+  }
+});
+
+exports.default = _default;

package/dist/findFlowFiles.js

@@ -1,181 +1,159 @@
-'use strict';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.findFlowFiles = findFlowFiles;
+exports.findFlowFilesWithSpinner = findFlowFilesWithSpinner;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+
+var _ora = _interopRequireDefault(require("ora"));
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 /**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
  * @format
  * 
  */
 
-const path = require('path');
-const fs = require('graceful-fs');
-
 /**
  * How many bytes we should look at for the Flow pragma.
  */
 const PRAGMA_BYTES = 5000;
-
 /**
  * Finds all of the Flow files in the provided directory as efficiently as
  * possible.
  */
-// If we use promises then Node.js will quickly run out of memory on
-// large codebases. Instead we use the callback API.
-module.exports = function findFlowFiles(rootDirectory, options) {
-  return new Promise((_resolve, _reject) => {
-    // Tracks whether or not we have rejected our promise.
-    let rejected = false;
-    // How many asynchronous tasks are waiting at the moment.
-    let waiting = 0;
-    // All the valid file paths that we have found.
-    const filePaths = [];
-
-    // Begin the recursion!
-    processDirectory(rootDirectory);
-
-    /**
-     * Process a directory by looking at all of its entries and recursing
-     * through child directories as is appropriate.
-     */
-    function processDirectory(directory) {
-      // If we were rejected then we should not continue.
-      if (rejected === true) {
-        return;
-      }
-      // We are now waiting on this asynchronous task.
-      waiting++;
-      // Read the directory...
-      fs.readdir(directory, (error, fileNames) => {
-        if (error) {
-          return reject(error);
-        }
-        // Process every file name that we got from reading the directory.
-        for (let i = 0; i < fileNames.length; i++) {
-          processFilePath(directory, fileNames[i]);
-        }
-        // We are done with this async task.
-        done();
-      });
-    }
 
-    /**
-     * Process a directory file path by seeing if it is a directory and either
-     * recursing or adding it to filePaths.
-     */
-    function processFilePath(directory, fileName) {
-      // If we were rejected then we should not continue.
-      if (rejected === true) {
-        return;
+async function findFlowFiles({
+  includeNonAtFlow,
+  rootDirectory
+}) {
+  // All the valid file paths that we have found.
+  const filePaths = []; // Begin the recursion!
+
+  await processDirectory(rootDirectory);
+  return filePaths;
+  /**
+   * Process a directory by looking at all of its entries and recursing
+   * through child directories as is appropriate.
+   */
+
+  async function processDirectory(directory) {
+    // Read the directory...
+    const fileNames = await _fsExtra.default.readdir(directory); // Process every file name that we got from reading the directory.
+
+    await Promise.all(fileNames.map(fileName => processFilePath(directory, fileName)));
+  }
+  /**
+   * Process a directory file path by seeing if it is a directory and either
+   * recursing or adding it to filePaths.
+   */
+
+
+  async function processFilePath(directory, fileName) {
+    // Get the file file path for this file.
+    const filePath = _path.default.join(directory, fileName); // Get the stats for the file.
+
+
+    const stats = await _fsExtra.default.lstat(filePath); // If this is a directory...
+
+    if (stats.isDirectory()) {
+      // ...and it is not an ignored directory...
+      if (fileName !== 'node_modules' && fileName !== 'flow-typed' && fileName !== '__flowtests__') {
+        // ...then recursively process the directory.
+        await processDirectory(filePath);
       }
-      // We are now waiting on this asynchronous task.
-      waiting++;
-      // Get the file file path for this file.
-      const filePath = path.join(directory, fileName);
-      // Get the stats for the file.
-      fs.lstat(filePath, (error, stats) => {
-        if (error) {
-          return reject(error);
-        }
-        // If this is a directory...
-        if (stats.isDirectory()) {
-          // ...and it is not an ignored directory...
-          if (fileName !== 'node_modules' && fileName !== 'flow-typed' && fileName !== '__flowtests__') {
-            // ...then recursively process the directory.
-            processDirectory(filePath);
-          }
-        } else if (stats.isFile()) {
-          // Otherwise if this is a JavaScript/JSX file and it is not an ignored
-          // JavaScript file...
-          const fileIsJsOrJsx = /\.jsx?$/.test(fileName);
-          const fileIsIgnored = fileName.endsWith('-flowtest.js');
-          if (fileIsJsOrJsx && !fileIsIgnored) {
-            // Then process the file path as JavaScript.
-            processJavaScriptFilePath(filePath, stats.size);
-          }
-          // If this is a Flow file then we don't need to check the file pragma
-          // and can add the file to our paths immediately.
-          if (fileName.endsWith('.flow')) {
-            filePaths.push(filePath);
-          }
-        }
-        // We are done with this async task
-        done();
-      });
-    }
+    } else if (stats.isFile()) {
+      // Otherwise if this is a JavaScript/JSX file and it is not an ignored
+      // JavaScript file...
+      const fileIsJsOrJsx = /\.jsx?$/.test(fileName);
+      const fileIsIgnored = fileName.endsWith('-flowtest.js');
+
+      if (fileIsJsOrJsx && !fileIsIgnored) {
+        // Then process the file path as JavaScript.
+        await processJavaScriptFilePath(filePath, stats.size);
+      } // If this is a Flow file then we don't need to check the file pragma
+      // and can add the file to our paths immediately.
 
-    /**
-     * Check if a file path really is a Flow file by looking for the 
-     * header pragma.
-     */
-    function processJavaScriptFilePath(filePath, fileByteSize) {
-      // If `all` was configured then we don't need to check for the Flow
-      // header pragma.
-      if (options.all) {
+
+      if (fileName.endsWith('.flow')) {
         filePaths.push(filePath);
-        return;
-      }
-      // If we were rejected then we should not continue.
-      if (rejected === true) {
-        return;
       }
-      // We are now waiting on this asynchronous task.
-      waiting++;
-      // Open the file path.
-      fs.open(filePath, 'r', (error, file) => {
-        if (error) {
-          return reject(error);
-        }
-        // Get the smaller of our pragma chars constant and the file byte size.
-        const bytes = Math.min(PRAGMA_BYTES, fileByteSize);
-        // Create the buffer we will read to.
-        const buffer = new Buffer(bytes);
-        // Read a set number of bytes from the file.
-        fs.read(file, buffer, 0, bytes, 0, error => {
-          if (error) {
-            return reject(error);
-          }
-          // If the buffer has the  pragma then add the file path to our
-          // final file paths array.
-          if (buffer.includes('@flow')) {
-            filePaths.push(filePath);
-          }
-          // Close the file.
-          fs.close(file, error => {
-            if (error) {
-              return reject(error);
-            }
-            // We are done with this async task
-            done();
-          });
-        });
-      });
     }
+  }
+  /**
+   * Check if a file path really is a Flow file by looking for the 
+   * header pragma.
+   */
 
-    /**
-     * Our implementation of resolve that will only actually resolve if we are
-     * done waiting everywhere.
-     */
-    function done() {
-      // We don't care if we were rejected.
-      if (rejected === true) {
-        return;
-      }
-      // Decrement the number of async tasks we are waiting on.
-      waiting--;
-      // If we are finished waiting then we want to resolve our promise.
-      if (waiting <= 0) {
-        if (waiting === 0) {
-          _resolve(filePaths);
-        } else {
-          reject(new Error(`Expected a positive number: ${waiting}`));
-        }
-      }
-    }
 
-    /**
-     * Our implementation of reject that also sets `rejected` to false.
-     */
-    function reject(error) {
-      rejected = true;
-      _reject(error);
+  async function processJavaScriptFilePath(filePath, fileByteSize) {
+    // If `all` was configured then we don't need to check for the Flow
+    // header pragma.
+    if (includeNonAtFlow) {
+      filePaths.push(filePath);
+      return;
+    } // Open the file path.
+
+
+    const file = await _fsExtra.default.open(filePath, 'r'); // Get the smaller of our pragma chars constant and the file byte size.
+
+    const bytes = Math.min(PRAGMA_BYTES, fileByteSize); // Create the buffer we will read to.
+
+    const buffer = Buffer.alloc(bytes); // Read a set number of bytes from the file.
+
+    await _fsExtra.default.read(file, buffer, 0, bytes, 0); // If the buffer has the  pragma then add the file path to our
+    // final file paths array.
+
+    if (buffer.includes('@flow')) {
+      filePaths.push(filePath);
+    } // Close the file.
+
+
+    await _fsExtra.default.close(file);
+  }
+}
+
+async function findFlowFilesWithSpinner(rootDirectory, options) {
+  // Create a new spinner.
+  const spinner = (0, _ora.default)({
+    text: _chalk.default.italic.cyan('Finding all the Flow files to be upgraded...'),
+    color: 'cyan',
+    isSilent: options.silent
+  }); // Start the spinner.
+
+  spinner.start(); // Find all of the Flow files in the directory we are upgrading.
+
+  const filePaths = await (() => {
+    try {
+      return findFlowFiles({
+        rootDirectory,
+        includeNonAtFlow: options.all
+      });
+    } catch (error) {
+      // Stop the spinner if we get an error.
+      spinner.stop();
+      throw error;
     }
-  });
-};
+  })(); // Stop the spinner.
+
+  spinner.stop(); // Log the number of Flow files that we found.
+
+  if (!options.silent) {
+    console.log(`Found ${_chalk.default.bold.cyan(filePaths.length)} Flow files.`);
+    console.log();
+  }
+
+  return filePaths;
+}

package/dist/runCodemods.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = runCodemods;
+
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+
+var _hermesTransform = require("hermes-transform");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * 
+ */
+async function runCodemods(codemods, filePaths, options) {
+  const results = await Promise.allSettled(filePaths.map(async filePath => {
+    const originalContents = await _fsExtra.default.readFile(filePath, 'utf8');
+    let contents = originalContents;
+
+    for (const codemod of codemods) {
+      contents = (0, _hermesTransform.transform)(contents, codemod.transform, options.prettierOptions);
+    }
+
+    if (originalContents !== contents) {
+      await _fsExtra.default.writeFile(filePath, contents, 'utf8');
+    }
+  }));
+}