flow-upgrade 1.1.0 → 2.0.0

package/README.md

@@ -27,9 +27,19 @@ npx flow-upgrade
 
 ## Options
 
+### `all`
+
 By default, Flow will only upgrade files that have an `// @flow` header comment.
 If you want to upgrade all of your JavaScript files you may pass in the `--all`:
 
 ```
 yarn create flow-upgrade --all
 ```
+
+### `prettierrc`
+
+Path to a `.prettierrc` file to use.
+Upgrade codemods rely upon [`prettier`][] to print the resulting code after transformation.
+If this is not provided, we will just use the defaults.
+
+[`prettier`]: https://www.npmjs.com/package/prettier

package/dist/Styled.js

@@ -1,10 +1,14 @@
-'use strict';
+"use strict";
 
 /**
+ * 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 chalk = require('chalk');
 
 exports.divider = function divider() {
@@ -20,22 +24,16 @@ exports.upgradeTitle = function upgradeTitle(title, n) {
 };
 
 exports.codeblock = function codeblock(code) {
-  return code
-  // Add indentation to the beginning of every line of code.
-  .split('\n').map(line => `    ${line}`).join('\n')
-  // Add highlighting for puncuation. We need to do this first otherwise it
+  return code // Add indentation to the beginning of every line of code.
+  .split('\n').map(line => `    ${line}`).join('\n') // Add highlighting for puncuation. We need to do this first otherwise it
   // breaks the other colors.
-  .replace(/([={}()\[\];<>,:.*/])/g, chalk.grey('$1'))
-  // Add highlighting for reserved keywords.
-  .replace(/(import|from|typeof|type|class|extends|static|return|function)/g, chalk.magenta('$1'))
-  // Add highlighting for strings.
+  .replace(/([={}()\[\];<>,:.*/])/g, chalk.grey('$1')) // Add highlighting for reserved keywords.
+  .replace(/(import|from|typeof|type|class|extends|static|return|function)/g, chalk.magenta('$1')) // Add highlighting for strings.
   .replace(/('[^\n]*')/g, chalk.green('$1'));
 };
 
 exports.list = function list(items) {
-  return items.map(item =>
-  // Indent every item and add a `- ` to the beginning of each line.
-  item.split('\n').map((line, i) => `${i === 0 ? chalk.grey('- ') : '  '}${line}`).join('\n'))
-  // Combine all of our items into one list string.
+  return items.map(item => // Indent every item and add a `- ` to the beginning of each line.
+  item.split('\n').map((line, i) => `${i === 0 ? chalk.grey('- ') : '  '}${line}`).join('\n')) // Combine all of our items into one list string.
   .join('\n');
 };

package/dist/Types.js

@@ -1 +1,21 @@
-'use strict';
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.codemod = codemod;
+
+/**
+ * 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 codemod(config) {
+  return { ...config,
+    kind: 'codemod'
+  };
+}

package/dist/bin/runSpecificCodemod.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+/**
+ * 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
+ * 
+ */
+"use strict";
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+
+var _yargs = _interopRequireDefault(require("yargs/yargs"));
+
+var _upgrade = _interopRequireDefault(require("../upgrade"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _findFlowFiles = require("../findFlowFiles");
+
+var _runCodemods = _interopRequireDefault(require("../runCodemods"));
+
+var _Styled = _interopRequireDefault(require("../Styled"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const CODEMOD_DIR = _path.default.resolve(__dirname, '..', 'codemods');
+
+async function main(args) {
+  const codemodNames = _fsExtra.default.readdirSync(CODEMOD_DIR, {
+    withFileTypes: false
+  }).map(f => _path.default.parse(f).name);
+
+  const yargs = (0, _yargs.default)(args).usage('Usage: flow-upgrade-codemod <codemod name>').positional('codemod name', {
+    describe: 'Your current flow version',
+    choices: codemodNames
+  }).options({
+    all: {
+      type: 'boolean',
+      describe: 'Include all files, not just those with the @flow pragma'
+    },
+    prettierrc: {
+      type: 'string',
+      describe: 'The path to a `.prettierrc` file for formatting the output.',
+      requiresArg: true
+    },
+    silent: {
+      type: 'boolean',
+      describe: 'Disable console log output.'
+    },
+    yes: {
+      type: 'boolean',
+      describe: 'Answer yes to all prompts.'
+    }
+  }).demandCommand(1).help('help').argv;
+  const prettierOptions = await (() => {
+    if (!yargs.prettierrc) {
+      return {};
+    }
+
+    return _fsExtra.default.readJSON(yargs.prettierrc);
+  })();
+  const options = {
+    all: !!yargs.all,
+    prettierOptions,
+    silent: !!yargs.silent,
+    yes: !!yargs.yes
+  };
+  const codemodName = yargs._[0];
+  const directory = process.cwd();
+
+  try {
+    const filePaths = await (0, _findFlowFiles.findFlowFilesWithSpinner)(directory, options); // $FlowExpectedError[unsupported-syntax]
+
+    const {
+      default: upgrade
+    } = await Promise.resolve(`${CODEMOD_DIR}/${codemodName}.js`).then(s => _interopRequireWildcard(require(s))); // Tell the user what we are about to do.
+
+    if (!options.silent) {
+      console.log(_Styled.default.sectionHeader('Codemods'));
+      console.log();
+      console.log('We are now going to run the following codemods:');
+      console.log();
+      console.log(_Styled.default.upgradeTitle(upgrade.title, 1));
+      console.log();
+      console.log(upgrade.description);
+      console.log();
+      console.log(_Styled.default.divider());
+      console.log();
+      console.log(`Running ${_chalk.default.bold.cyan(1)} codemod...`);
+      console.log();
+    }
+
+    switch (upgrade.kind) {
+      case 'codemod':
+        await (0, _runCodemods.default)([upgrade], filePaths, options);
+        break;
+      // Throw an error for all other kinds of upgrades.
+
+      default:
+        throw new Error(`Unexpected upgrade kind: '${upgrade.kind}'`);
+    }
+  } catch (error) {
+    console.error(_chalk.default.red(error ? error.stack || error : error));
+  }
+}
+
+void main(process.argv.slice(2));

package/dist/bin/upgrade.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+/**
+ * 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
+ * 
+ */
+"use strict";
+
+var _chalk = _interopRequireDefault(require("chalk"));
+
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+
+var _yargs = _interopRequireDefault(require("yargs/yargs"));
+
+var _upgrade = _interopRequireDefault(require("../upgrade"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+async function main(args) {
+  const yargs = (0, _yargs.default)(args).usage('Usage: flow-upgrade <current version> <target version>').positional('current version', {
+    describe: 'Your current flow version'
+  }).positional('target version', {
+    describe: 'The flow version you are upgrading to'
+  }).options({
+    all: {
+      type: 'boolean',
+      describe: 'Include all files, not just those with the @flow pragma'
+    },
+    prettierrc: {
+      type: 'string',
+      describe: 'The path to a `.prettierrc` file for formatting the output.',
+      requiresArg: true
+    },
+    silent: {
+      type: 'boolean',
+      describe: 'Disable console log output.'
+    },
+    yes: {
+      type: 'boolean',
+      describe: 'Answer yes to all prompts.'
+    }
+  }).demandCommand(2).help('help').argv;
+  const prettierOptions = await (() => {
+    if (!yargs.prettierrc) {
+      return {};
+    }
+
+    return _fsExtra.default.readJSON(yargs.prettierrc);
+  })();
+  const options = {
+    all: !!yargs.all,
+    prettierOptions,
+    silent: !!yargs.silent,
+    yes: !!yargs.yes
+  }; // For now we are asking for the version numbers out of convenience. When we add
+  // upgrades for future versions we will need to check `.flowconfig` or
+  // `flow-bin` for the current version and allow the new version to be
+  // configurable. (But still default to the latest version.)
+
+  const fromVersion = yargs._[0];
+  const toVersion = yargs._[1];
+
+  try {
+    await (0, _upgrade.default)(process.cwd(), fromVersion, toVersion, options);
+  } catch (error) {
+    console.error(_chalk.default.red(error ? error.stack || error : error));
+  }
+}
+
+void main(process.argv.slice(2));

package/dist/codemodUtils/getClassMemberName.js

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getClassMemberName = getClassMemberName;
+
+/**
+ * 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 getClassMemberName(member) {
+  if (member.key.type === 'PrivateIdentifier') {
+    return `#${member.key.name}`;
+  }
+
+  if (member.computed === true || member.key.type !== 'Identifier') {
+    return null;
+  }
+
+  return member.key.name;
+}

package/dist/codemodUtils/replaceMethodWithArrowProp.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.replaceMethodWithArrowProp = replaceMethodWithArrowProp;
+
+var _hermesTransform = require("hermes-transform");
+
+/**
+ * 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
+ * 
+ */
+
+/**
+ * Converts method definition to an arrow function property
+ * ```
+ * method<T>(arg) { ... }
+ * // to
+ * +method = <T>(arg) => { ... };
+ * ```
+ */
+function replaceMethodWithArrowProp(context, method, name) {
+  context.replaceNode(method, _hermesTransform.t.PropertyDefinition({
+    computed: false,
+    declare: false,
+    key: _hermesTransform.t.Identifier({
+      name,
+      // for types-first compliance, this should ideally be filled out for
+      // non-private members. However it's *super* complicated to correctly
+      // handle these cases statically (type parameters and default args make
+      // it hard).
+      // So instead we just ignore it and they can be filled later using a
+      // type-aware codemod like
+      // ```
+      // flow codemod annotate-exports --write --munge-underscore-members --max-type-size 25
+      // ```
+      typeAnnotation: null
+    }),
+    optional: false,
+    static: false,
+    value: _hermesTransform.t.ArrowFunctionExpression({
+      async: method.value.async,
+      body: method.value.body,
+      params: method.value.params,
+      predicate: method.value.predicate,
+      typeParameters: method.value.typeParameters,
+      returnType: method.value.returnType
+    }),
+    // methods are readonly, so we mark the property as readonly as well
+    variance: _hermesTransform.t.Variance({
+      kind: 'plus'
+    })
+  }));
+}

package/dist/codemods/collapseObjectInitialization.js

@@ -0,0 +1,250 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _hermesTransform = require("hermes-transform");
+
+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
+ * 
+ */
+var _default = (0, _Types.codemod)({
+  title: 'Collapse Object Initialization',
+  description: 'Converts static object assignments to inline properties',
+  transform: context => {
+    function getStatementContainerArray(stmtNode) {
+      const parent = stmtNode.parent;
+
+      switch (parent.type) {
+        case 'SwitchCase':
+          {
+            return parent.consequent;
+          }
+
+        case 'BlockStatement':
+          {
+            return parent.body;
+          }
+
+        case 'Program':
+          {
+            // $FlowIgnore[incompatible-return]
+            return parent.body;
+          }
+
+        default:
+          return null;
+      }
+    }
+
+    function getNextSibling(node) {
+      if (node == null) {
+        return null;
+      }
+
+      const parentContainer = getStatementContainerArray(node);
+
+      if (parentContainer == null) {
+        return null;
+      }
+
+      const nodeIndex = parentContainer.indexOf(node);
+
+      if (nodeIndex === -1) {
+        return null;
+      }
+
+      return parentContainer[nodeIndex + 1];
+    }
+
+    function containsReference(node, references) {
+      return references.some(reference => {
+        const refRange = reference.identifier.range;
+        return node.range[0] <= refRange[0] && refRange[1] <= node.range[1];
+      });
+    }
+
+    function processStmtNode(idNode, references, stmtNode) {
+      if (stmtNode.type !== 'ExpressionStatement') {
+        return {
+          type: 'abort'
+        };
+      }
+
+      const exprNode = stmtNode.expression;
+
+      if (exprNode.type !== 'AssignmentExpression') {
+        return {
+          type: 'abort'
+        };
+      }
+
+      const leftNode = exprNode.left;
+
+      if (leftNode.type !== 'MemberExpression') {
+        return {
+          type: 'abort'
+        };
+      }
+
+      const exprRightNode = exprNode.right;
+
+      if (containsReference(exprRightNode, references)) {
+        return {
+          type: 'abort'
+        };
+      }
+
+      const memberObjectNode = leftNode.object;
+      const memberPropertyNode = leftNode.property;
+
+      if (memberObjectNode.type === 'Identifier' && memberObjectNode.name === idNode.name && memberPropertyNode.type === 'Identifier') {
+        const shorthand = !leftNode.computed && exprRightNode.type === 'Identifier' && exprRightNode.name === memberPropertyNode.name; // $FlowIgnore[incompatible-type-arg] You gonna have to trust me
+
+        const property = _hermesTransform.t.Property({
+          key: memberPropertyNode,
+          value: exprRightNode,
+          computed: leftNode.computed,
+          kind: 'init',
+          method: false,
+          // $FlowIgnore[incompatible-call]
+          shorthand
+        });
+
+        return {
+          type: 'property',
+          keyName: memberPropertyNode.name,
+          property,
+          computed: leftNode.computed
+        };
+      }
+
+      return {
+        type: 'abort'
+      };
+    }
+
+    function isWriteToObject(ref) {
+      let currNode = ref.identifier;
+
+      while (currNode.parent.type === 'MemberExpression' && currNode.parent.object === currNode) {
+        currNode = currNode.parent;
+      }
+
+      return currNode.parent.type === 'AssignmentExpression';
+    }
+
+    return {
+      VariableDeclarator(node) {
+        const initNode = node.init;
+
+        if (initNode == null || initNode.type !== 'ObjectExpression' || initNode.properties.length > 0) {
+          return;
+        }
+
+        const idNode = node.id;
+
+        if (idNode.type !== 'Identifier' || idNode.typeAnnotation != null) {
+          return;
+        }
+
+        const stmtNode = node.parent;
+
+        if (stmtNode.type !== 'VariableDeclaration') {
+          throw new Error(context.buildCodeFrame(stmtNode, `This is not right, parent of VariableDeclarator should always be a VariableDeclaration, instead got a "${stmtNode.type}"`));
+        }
+
+        const binding = context.getBinding(idNode.name);
+
+        if (binding == null) {
+          throw new Error(context.buildCodeFrame(idNode, `No binding found for node of name "${idNode.name}"`));
+        }
+
+        let nextStmtNode = stmtNode;
+        let finish = false;
+        const objectProperties = [];
+
+        while (finish !== true && (nextStmtNode = getNextSibling(nextStmtNode)) && nextStmtNode != null) {
+          const out = processStmtNode(idNode, binding.references, nextStmtNode);
+
+          switch (out.type) {
+            case 'abort':
+              {
+                finish = true;
+                break;
+              }
+
+            case 'skip':
+              {
+                break;
+              }
+
+            case 'property':
+              {
+                const {
+                  type: _type,
+                  ...rest
+                } = out;
+                objectProperties.push([rest, nextStmtNode]);
+                break;
+              }
+          }
+        }
+
+        if (objectProperties.length > 0) {
+          const assignmentRefsCount = binding.references.reduce((acc, ref) => {
+            if (isWriteToObject(ref)) {
+              return acc + 1;
+            }
+
+            return acc;
+          }, 0);
+
+          if (assignmentRefsCount !== objectProperties.length) {
+            console.error(context.buildCodeFrame(stmtNode, 'Object had non inlinable and inlineable properties')); // If you don't wish to codemod these mixed objects return here.
+            // return;
+          }
+
+          const keyNames = new Set();
+
+          for (const [{
+            keyName,
+            computed
+          }, _] of objectProperties) {
+            const name = `${computed ? 'c' : 'v'}-${keyName}`;
+
+            if (keyNames.has(name)) {
+              console.error(context.buildCodeFrame(stmtNode, `Object has duplicate key of "${keyName}"`));
+              return;
+            }
+
+            keyNames.add(name);
+          }
+
+          const newProperties = objectProperties.map(([{
+            property
+          }, _]) => property);
+          context.replaceNode(initNode, _hermesTransform.t.ObjectExpression({
+            properties: newProperties
+          }));
+          objectProperties.forEach(([_, stmtToRemove]) => {
+            context.removeStatement(stmtToRemove);
+          });
+        }
+      }
+
+    };
+  }
+});
+
+exports.default = _default;

package/dist/codemods/convertImplicitInexactObjectTypes.js

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+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
+ * 
+ */
+var _default = (0, _Types.codemod)({
+  title: 'Make implicitly inexact object types explicitly inexact',
+  description: 'Convert implicitly inexact object type syntax `{}` to explicitly inexact `{...}`',
+  transform: context => {
+    return {
+      ':not(InterfaceDeclaration, InterfaceTypeAnnotation, DeclareInterface, DeclareClass) > ObjectTypeAnnotation[inexact=false][exact=false]'(node) {
+        // $FlowFixMe[incompatible-call] `inexact` can be true, as is the case with `{...}`
+        context.modifyNodeInPlace(node, {
+          inexact: true
+        });
+      }
+
+    };
+  }
+});
+
+exports.default = _default;

package/dist/codemods/removeAnnotationsInDestructuring.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+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
+ * 
+ */
+var _default = (0, _Types.codemod)({
+  title: 'Remove Annotations In Destructuring',
+  description: 'Remove annotations nested inside of destructuring. These are not valid Flow syntax.',
+  transform: context => {
+    return {
+      ':matches(ArrayPattern, ObjectPattern) > :matches(Identifier, ArrayPattern, ObjectPattern)[typeAnnotation!=null]'(node) {
+        context.modifyNodeInPlace(node, {
+          typeAnnotation: null
+        });
+      },
+
+      ':matches(ArrayPattern, ObjectPattern) > :matches(RestElement, Property) > [typeAnnotation!=null]'(node) {
+        context.modifyNodeInPlace(node, {
+          typeAnnotation: null
+        });
+      }
+
+    };
+  }
+});
+
+exports.default = _default;