flow-upgrade 1.0.4 → 2.0.1

package/dist/codemods/ReactUtils.js

@@ -1,140 +0,0 @@
-/**
- * @format
- * 
- */
-
-'use strict';
-
-module.exports = j => {
-  /**
-   * Has this path imported the react module and given a name it a name? If
-   * React is imported like:
-   *
-   * ```
-   * import {Component} from 'react';
-   * ```
-   *
-   * Then it does not count.
-   */
-  function getImportedReactName(path) {
-    // All of the modules we want to treat as React.
-    const REACT_MODULES = new Set(['react', 'React']);
-    // Find the first require for React that does not destructure React but
-    // instead gives it a name.
-    const reactRequire = path.findVariableDeclarators().filter(j.filters.VariableDeclarator.requiresModule(Array.from(REACT_MODULES))).nodes().find(node => node.id && node.id.type === 'Identifier');
-    // If we found a require for React then return the name.
-    if (reactRequire) {
-      return reactRequire.id.name;
-    }
-    // Get all of the import declarations that import React.
-    const reactImports = path.find(j.ImportDeclaration, {
-      type: 'ImportDeclaration',
-      source: {
-        type: 'Literal',
-        value: _value => REACT_MODULES.has(_value)
-      }
-    }).nodes();
-    // For all of the React imports...
-    for (let i = 0; i < reactImports.length; i++) {
-      const reactImport = reactImports[i];
-      // ...and for all of each import's specifiers...
-      for (let j = 0; j < reactImport.specifiers.length; j++) {
-        const specifier = reactImport.specifiers[j];
-        // ...check to see if it is either a default specifier or a namespace
-        // specifier. If it is either and it has a local name then return that
-        // local name.
-        if ((specifier.type === 'ImportDefaultSpecifier' || specifier.type === 'ImportNamespaceSpecifier') && specifier.local && specifier.local.type === 'Identifier') {
-          return specifier.local.name;
-        }
-      }
-    }
-    // Otherwise we can't find anything and should return null.
-    return null;
-  }
-
-  /**
-   * Gets a pattern that can be used with jscodeshift that matches value nodes
-   * like `React.Component`. If React was not imported then null will be
-   * returned.
-   */
-  function getImportedComponentClassPattern(path) {
-    // All of the places where we want to treat as React.
-    const REACT_MODULES = new Set(['React', 'react', 'react/addons', 'react-native']);
-    // The names of the exports from `REACT_MODULES` that are components
-    // classes.
-    const COMPONENT_CLASSES = new Set(['Component', 'PureComponent']);
-    // Do we require React?
-    const requiresReact = path.findVariableDeclarators().filter(j.filters.VariableDeclarator.requiresModule(Array.from(REACT_MODULES))).size() > 0;
-    // Do we import React?
-    const importsReact = path.find(j.ImportDeclaration, {
-      type: 'ImportDeclaration',
-      source: {
-        type: 'Literal',
-        value: _value2 => REACT_MODULES.has(_value2)
-      }
-    }).size() > 0;
-    // If we neither require React or import React then we cannot get a
-    // component class pattern.
-    if (!requiresReact && !importsReact) {
-      return null;
-    }
-    // We want to match two different patterns so we jump straight to a
-    // function.
-    //
-    // For now we use a simple implementation where we assume Component and/or
-    // PureComponent has not been renamed. In the future if it becomes a problem
-    // then we should check to see if Component and/or PureComponent were
-    // renamed.
-    return node => node && (
-    // Matches: `Component`.
-    node.type === 'Identifier' && COMPONENT_CLASSES.has(node.name) ||
-    // Matches: `React.Component`.
-    node.type === 'MemberExpression' && node.object.type === 'Identifier' && node.object.name === 'React' && node.property.type === 'Identifier' && COMPONENT_CLASSES.has(node.property.name) ||
-    // Matches: `React.Component` but in the type position.
-    node.type === 'QualifiedTypeIdentifier' && node.qualification.type === 'Identifier' && node.qualification.name === 'React' && node.id.type === 'Identifier' && COMPONENT_CLASSES.has(node.id.name));
-  }
-
-  /**
-   * Checks for a very specific pattern:
-   *
-   * ```
-   * const React = require('react');
-   * const {Element} = React;
-   * ```
-   *
-   * or:
-   *
-   * ```
-   * import type {Element} from 'react';
-   * ```
-   *
-   * At this moment we do not care about generalizing these patterns!
-   */
-  function hasDestructuredElement(path, reactName) {
-    // All of the places where we want to treat as React.
-    const REACT_MODULES = new Set(['React', 'react', 'react-native']);
-    reactName = reactName || getImportedReactName(path);
-    return path.find(j.ImportDeclaration, {
-      specifiers: _specifiers => _specifiers.find(specifier => specifier && specifier.type === 'ImportSpecifier' && specifier.imported && specifier.imported.type === 'Identifier' && specifier.imported.name === 'Element' && specifier.local && specifier.local.type === 'Identifier' && specifier.local.name === 'Element'),
-      source: {
-        type: 'Literal',
-        value: _value3 => REACT_MODULES.has(_value3)
-      }
-    }).size() > 0 || path.find(j.VariableDeclarator, {
-      init: {
-        type: 'Identifier',
-        name: reactName
-      },
-      id: {
-        type: 'ObjectPattern',
-        properties: _properties => !!_properties.find(property => property && !property.method && property.shorthand && property.key && property.key.type === 'Identifier' && property.key.name === 'Element' && property.value && property.value.type === 'Identifier' && property.value.name === 'Element')
-      }
-    }).size() > 0;
-  }
-
-  return {
-    getImportedReactName,
-    getImportedComponentClassPattern,
-    hasDestructuredElement
-  };
-};

package/dist/codemods/createAggregateCodemod.js

@@ -1,36 +0,0 @@
-"use strict";
-
-/**
- * @format
- * 
- */
-
-/**
- * Creates a transform function that can be used with `jscodeshift` that is the
- * aggregate of the transform paths.
- *
- * This file is not required directly when we run `flow-upgrade`. Instead it is
- * initialized in a `jscodeshift` worker.
- */
-module.exports = transformPaths => {
-  return (file, api) => {
-    // Get the jscodeshift API and parse our source file.
-    const j = api.jscodeshift;
-    // Parse ths source file.
-    const root = j(file.source);
-    // Iterate through all of our transform paths so that we can apply them.
-    const skipped = transformPaths.reduce((skipped, transformPath) => {
-      // Require the transform path.
-      const transform = require(transformPath);
-      // Use the transform to codemod the file.
-      const notSkipped = transform(j, root);
-      // If all of the transforms return true then skipped will be true.
-      return skipped && !notSkipped;
-    },
-    // If we have no codemods then skipped should be true.
-    true);
-    // Either return null or the new source file depending on whether or all the
-    // transforms skipped.
-    return skipped ? null : root.toSource();
-  };
-};

package/dist/codemods/runCodemods.js

@@ -1,53 +0,0 @@
-'use strict';
-
-function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
-
-/**
- * @format
- * 
- */
-
-const path = require('path');
-const fs = require('fs');
-const Runner = require('jscodeshift/src/Runner');
-
-const AGGREGATE_CODEMOD_UTIL = path.join(__dirname, 'createAggregateCodemod.js');
-
-/**
- * Runs some codemods.
- *
- * We use the synchronous methods from `fs` for now as we fully expect for this
- * function to block the running process.
- */
-module.exports = (() => {
-  var _ref = _asyncToGenerator(function* (transformPaths, filePaths) {
-    // Create a temporary for our aggregate codemod file.
-    const aggregateTransformPath = path.join(fs.mkdtempSync('/tmp/flow-upgrade-'), 'codemod.js');
-    // The contents of our transform file.
-    const aggregateTransformContents = `
-/**
- * This jscodeshift transform file was automatically generated by:
- * ${__filename}
- */
-module.exports = require(${JSON.stringify(AGGREGATE_CODEMOD_UTIL)})([
-${transformPaths.map(function (transformPath) {
-      return `  ${JSON.stringify(transformPath)},`;
-    }).join('\n')}
-]);
-`.slice(1);
-    // Write the codemod to the folder we created for it.
-    fs.writeFileSync(aggregateTransformPath, aggregateTransformContents);
-    // Run the codemod with jscodeshift! The runner returns a promise which we
-    // will wait for.
-    yield Runner.run(aggregateTransformPath, filePaths, {
-      parser: 'flow',
-      verbose: 0
-    });
-  });
-
-  function runCodemods(_x, _x2) {
-    return _ref.apply(this, arguments);
-  }
-
-  return runCodemods;
-})();

package/dist/index.js

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * @format
- * 
- */
-
-const yargs = require('yargs').argv;
-const chalk = require('chalk');
-const upgrade = require('./upgrade');
-
-const options = {
-  all: !!yargs.all
-};
-
-// For now we are hardcoding 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 = '0.52.0';
-const toVersion = '0.53.0';
-
-upgrade(process.cwd(), fromVersion, toVersion, options).catch(error => {
-  console.error(chalk.red(error ? error.stack || error : error));
-});

package/dist/upgrades/0.53.0/ReactComponentExplicitTypeArgs/codemod.js

@@ -1,154 +0,0 @@
-'use strict';
-
-const LIFECYCLE_METHODS = new Map([['componentWillReceiveProps', ['props']], ['shouldComponentUpdate', ['props', 'state']], ['componentWillUpdate', ['props', 'state']], ['componentDidUpdate', ['props', 'state']]]);
-
-/**
- * ```
- * class MyComponent extends React.Component {
- *   props: Props;
- *   ...
- * }
- * ```
- *
- * ==>
- *
- * ```
- * class MyComponent extends React.Component<void, Props> {
- *   ...
- * }
- * ```
- *
- * See `./fixtures` for more examples.
- */
-module.exports = (j, root) => {
-  const ReactUtils = require('../../../codemods/ReactUtils')(j);
-  const componentPattern = ReactUtils.getImportedComponentClassPattern(root);
-
-  // Only proceed with the transform if we see that React is being used.
-  if (!componentPattern) {
-    return false;
-  }
-
-  // The fallback type annotations we will use if we can't find anything.
-  const fallbackDefaultPropsTypeAnnotation = j.genericTypeAnnotation(j.identifier('$FlowFixMeDefaultProps'), null);
-  const fallbackPropsTypeAnnotation = j.genericTypeAnnotation(j.identifier('$FlowFixMeProps'), null);
-  const fallbackStateTypeAnnotation = j.genericTypeAnnotation(j.identifier('$FlowFixMeState'), null);
-
-  root.find(j.ClassDeclaration, { superClass: componentPattern }).filter(path => !path.node.superTypeParameters).forEach(handlePath);
-
-  root.find(j.ClassExpression, { superClass: componentPattern }).filter(path => !path.node.superTypeParameters).forEach(handlePath);
-
-  return true;
-
-  function handlePath(path) {
-    // Initialize the type annotations for the three generic parameters we
-    // will need to pass into `Component`. `defaultProps` and `state` default
-    // to void. If we can't find a type we assume they do not exist. `props`,
-    // however, we set to null initially as we have a few fallback mechanisms.
-    let defaultPropsTypeAnnotation = j.voidTypeAnnotation();
-    let propsTypeAnnotation = null;
-    let stateTypeAnnotation = null;
-    // Some components use the constructor to type props. If they do we want
-    // to remember that, but we do not want to override any value in
-    // `propsTypeAnnotation`.
-    let constructorPropsTypeAnnotation = null;
-    // We want to try to get the props and state type annotation from lifecycle
-    // methods as well.
-    let propsLifecycleTypeAnnotation = null;
-    let stateLifecycleTypeAnnotation = null;
-    // If we find any reference to `this.props` then we set this to true. We
-    // do not need to compute this value if we found a type for
-    // `propsTypeAnnotation` or `constructorPropsTypeAnnotation`.
-    let usesPropsSomewhere = false;
-    // If we find any reference to `this.state` then we set this to true. We
-    // do not need to compute this value if we found a type for
-    // `stateTypeAnnotation`.
-    let usesStateSomewhere = false;
-    // Look at all our class members and remove `props`, `state`, or
-    // `defaultProps` if they are only used to specify a type.
-    path.node.body.body = path.node.body.body.filter(member => {
-      // Do we need to check to see if props or state were used?
-      const checkForPropsUsage = !propsTypeAnnotation && !constructorPropsTypeAnnotation && !usesPropsSomewhere;
-      const checkForStateUsage = !stateTypeAnnotation && !usesStateSomewhere;
-      // Check that either props or state were used in a non-static member.
-      if (member && !member.static && (checkForPropsUsage || checkForStateUsage)) {
-        // Get the nodes for all of the either props identifiers or state
-        // identifiers.
-        const nodes = j(member).find(j.Identifier, {
-          name: _name => checkForPropsUsage && _name === 'props' || checkForStateUsage && _name === 'state'
-        }).nodes();
-        // If we are checking for props usage see if we found a props
-        // identifier.
-        if (checkForPropsUsage) {
-          usesPropsSomewhere = nodes.findIndex(node => node.name === 'props') !== -1;
-        }
-        // If we are checking for state usage see if we found a state
-        // identifier.
-        if (checkForStateUsage) {
-          usesStateSomewhere = nodes.findIndex(node => node.name === 'state') !== -1;
-        }
-      }
-
-      if (
-      // Class properties like defaultProps, props, and state.
-      member.type === 'ClassProperty' && member.key.type === 'Identifier') {
-        if (member.static && member.key.name === 'defaultProps') {
-          defaultPropsTypeAnnotation = member.typeAnnotation ? member.typeAnnotation.typeAnnotation : fallbackDefaultPropsTypeAnnotation;
-          return !!member.value;
-        } else if (!member.static && member.key.name === 'props') {
-          propsTypeAnnotation = member.typeAnnotation ? member.typeAnnotation.typeAnnotation : fallbackPropsTypeAnnotation;
-          return !!member.value;
-        } else if (!member.static && member.key.name === 'state') {
-          stateTypeAnnotation = member.typeAnnotation ? member.typeAnnotation.typeAnnotation : fallbackStateTypeAnnotation;
-          return !!member.value;
-        } else {
-          return true;
-        }
-      } else if (
-      // The constructor method.
-      member.type === 'MethodDefinition' && member.key.type === 'Identifier' && member.key.name === 'constructor' && member.value && member.value.type === 'FunctionExpression' && member.value.params[0]) {
-        constructorPropsTypeAnnotation = member.value.params[0].typeAnnotation ? member.value.params[0].typeAnnotation.typeAnnotation : fallbackPropsTypeAnnotation;
-        return true;
-      } else if (
-      // Lifecycle methods.
-      member.type === 'MethodDefinition' && member.key.type === 'Identifier' && LIFECYCLE_METHODS.has(member.key.name) && member.value && member.value.type === 'FunctionExpression') {
-        const paramNames = LIFECYCLE_METHODS.get(member.key.name);
-        // For all of the parameters...
-        for (let i = 0; i < member.value.params.length; i++) {
-          const param = member.value.params[i];
-          const paramName = paramNames[i];
-          // If we have any excuse to stop iterating over the lifecycle method
-          // params then take it.
-          if (!param || !paramName || param.type === 'RestElement') {
-            return true;
-          }
-          // Get the type annotation. (Or the fallback.)
-          const typeAnnotation = param.typeAnnotation && param.typeAnnotation.type === 'TypeAnnotation' && param.typeAnnotation.typeAnnotation;
-          // If this is a props param and we don't yet have a lifecycle type
-          // annotation.
-          if (paramName === 'props' && !propsLifecycleTypeAnnotation) {
-            propsLifecycleTypeAnnotation = typeAnnotation || fallbackPropsTypeAnnotation;
-          }
-          // If this is a state param and we don't yet have a lifecycle type
-          // annotation.
-          if (paramName === 'state' && !stateLifecycleTypeAnnotation) {
-            stateLifecycleTypeAnnotation = typeAnnotation || fallbackStateTypeAnnotation;
-          }
-        }
-        return true;
-      } else {
-        return true;
-      }
-    });
-    // Set the super type parameters to the class.
-    path.node.superTypeParameters = j.typeParameterInstantiation([defaultPropsTypeAnnotation,
-    // Use the props type annotation if we have it. If not try using the
-    // constructor props annotation. Otherwise, if we found any mention to
-    // props use the any type. If not then use an empty object type.
-    propsTypeAnnotation || constructorPropsTypeAnnotation || propsLifecycleTypeAnnotation || (usesPropsSomewhere ? fallbackPropsTypeAnnotation : j.objectTypeAnnotation([])),
-    // The state type annotation may be null. If it is then it will be
-    // filtered out at the end. If state was used somewhere then we need the
-    // fallback type annotation.
-    stateTypeAnnotation || stateLifecycleTypeAnnotation || (usesStateSomewhere ? fallbackStateTypeAnnotation : null)].filter(Boolean));
-  }
-};

package/dist/upgrades/0.53.0/ReactComponentExplicitTypeArgs/index.js

@@ -1,75 +0,0 @@
-'use strict';
-
-/**
- * @format
- * 
- */
-
-const path = require('path');
-const Styled = require('../../../Styled');
-
-exports.kind = 'codemod';
-
-exports.title = 'Move inferred React.Component type arguments to their generic positions.';
-
-exports.description = `
-The recommended way to write React components used to be:
-
-${Styled.codeblock(`
-import React from 'react';
-
-type DefaultProps = { /* ... */ };
-type Props = { /* ... */ };
-type State = { /* ... */ };
-
-class MyComponent extends React.Component {
-  static defaultProps: DefaultProps = { /* ... */ };
-
-  props: Props;
-  state: State = { /* ... */ };
-
-  render() {
-    return /* ... */;
-  }
-}`.slice(1))}
-
-While you would write React.Component in this way without type arguments the
-signature for React.Component was in fact:
-React.Component<DefaultProps, Props, State>. So for Flow to get from the
-component style above to a place where React components had the correct type
-arguments it would turn:
-
-${Styled.codeblock(`
-class MyComponent extends React.Component {`.slice(1))}
-
-...into:
-
-${Styled.codeblock(`
-class MyComponent extends React.Component<*, *, *> {`.slice(1))}
-
-Where the star (*) meant "infer." However, this approach is difficult to
-understand, reduces type trustworthiness, and has some negative impacts on
-performance as Flow needs to carry inference information around everywhere.
-
-This upgrade runs a codemod to make the type arguments you pass into
-React.Component explicit. We take the code in the first example above and turn
-it into:
-
-${Styled.codeblock(`
-import React from 'react';
-
-type DefaultProps = { /* ... */ };
-type Props = { /* ... */ };
-type State = { /* ... */ };
-
-class MyComponent extends React.Component<DefaultProps, Props, State> {
-  static defaultProps = { /* ... */ };
-
-  state = { /* ... */ };
-
-  render() {
-    return /* ... */;
-  }
-}`.slice(1))}`.slice(1);
-
-exports.transformPath = path.join(__dirname, './codemod.js');

package/dist/upgrades/0.53.0/ReactComponentSimplifyTypeArgs/codemod.js

@@ -1,65 +0,0 @@
-'use strict';
-
-/**
- * This codemod depends on ReactComponentExplicitTypeArgs! It assumes that the
- * code was first transformed using that.
- *
- * ```
- * class MyComponent extends React.Component<void, Props> {
- *   ...
- * }
- * ```
- *
- * ==>
- *
- * ```
- * class MyComponent extends React.Component<Props> {
- *   ...
- * }
- * ```
- *
- * See `./fixtures` for more examples.
- */
-
-module.exports = (j, root) => {
-  const ReactUtils = require('../../../codemods/ReactUtils')(j);
-  const componentPattern = ReactUtils.getImportedComponentClassPattern(root);
-
-  // Only proceed with the transform if we see that React is being used.
-  if (!componentPattern) {
-    return false;
-  }
-
-  root.find(j.ClassDeclaration, {
-    superClass: componentPattern,
-    superTypeParameters: {
-      type: 'TypeParameterInstantiation'
-    }
-  }).forEach(handlePath);
-
-  root.find(j.ClassExpression, {
-    superClass: componentPattern,
-    superTypeParameters: {
-      type: 'TypeParameterInstantiation'
-    }
-  }).forEach(handlePath);
-
-  function handlePath(path) {
-    // Remove the first super type parameter.
-    const defaultPropsType = path.node.superTypeParameters.params.shift();
-    // If we have a default props type that is not `void` and a class body then
-    // we might want to add the default props type to our class body.
-    if (defaultPropsType && defaultPropsType.type !== 'VoidTypeAnnotation' && path.node.body) {
-      const body = path.node.body.body;
-      // See if we already have a static default props class property.
-      const hasDefaultProps = !!body.find(node => node.type === 'ClassProperty' && node.static === true && node.key && node.key.type === 'Identifier' && node.key.name === 'defaultProps');
-      // If we do not have a static default props class property then we want to
-      // add one to our class body using the default props type that we shifted.
-      if (!hasDefaultProps) {
-        body.unshift(j.classProperty(j.identifier('defaultProps'), null, j.typeAnnotation(defaultPropsType), true));
-      }
-    }
-  }
-
-  return true;
-};

package/dist/upgrades/0.53.0/ReactComponentSimplifyTypeArgs/index.js

@@ -1,52 +0,0 @@
-'use strict';
-
-/**
- * @format
- * 
- */
-
-const path = require('path');
-const Styled = require('../../../Styled');
-
-exports.kind = 'codemod';
-
-exports.title = 'Simplify React.Component type arguments.';
-
-exports.description = `
-A React.Component used to require three type arguments like this:
-React.Component<DefaultProps, Props, State>. However, requiring DefaultProps
-whenever using type arguments doesn't make much sense. Also, requiring State
-for a component that does not use state, or in a consumer that doesn't care
-about State also doesn't make much sense.
-
-So we changed Flow so that we only require Props. If you write:
-React.Component<Props> then State is assumed to be undefined and default props
-will be inferred from the statics of your component class. A component written
-without state but with default props in this new style looks like:
-
-${Styled.codeblock(`
-import React from 'react';
-
-type Props = { /* ... */ };
-
-class MyComponent extends React.Component<Props> {
-  static defaultProps = { /* ... */ };
-}`.slice(1))}
-
-Default props is inferred from the static defaultProps object literal. If you
-want a component with state add a second type argument:
-
-${Styled.codeblock(`
-import React from 'react';
-
-type Props = { /* ... */ };
-type State = { /* ... */ };
-
-class MyComponent extends React.Component<Props, State> {
-  static defaultProps = { /* ... */ };
-}`.slice(1))}
-
-This upgrade will remove DefaultProps from the type arguments of all your
-React components.`.slice(1);
-
-exports.transformPath = path.join(__dirname, './codemod.js');