Codemod $Shape to Partial in xplat, suppressing errors [4] (#36960)

Summary:
X-link: facebook/react-native#36960

We're deprecating the unsafe `$Shape` and moving to the safe `Partial`: https://fb.workplace.com/groups/flowlang/posts/1251655088773485

I have previously codemodded all locations that do not cause errors. Now start on the remaining ones: codemod and suppress.

Changelog: [Internal]

Reviewed By: SamChou19815

Differential Revision: D45076273

fbshipit-source-id: 27ebf33370143e19751dbdcfcc1876cf3c586e14

flow-typed/babel-traverse.js

@@ -1417,7 +1417,7 @@ declare module '@babel/traverse' {
     state: TState,
   ) => void;
 
-  declare export type VisitNodeObject<-TNode: BabelNode, TState> = $Shape<{
+  declare export type VisitNodeObject<-TNode: BabelNode, TState> = Partial<{
     enter(path: NodePath<TNode>, state: TState): void,
     exit(path: NodePath<TNode>, state: TState): void,
   }>;

flow-typed/npm/yargs_v17.x.x.js

@@ -9,7 +9,7 @@ declare module "yargs" {
     ...
   };
 
-  declare type Options = $Shape<{
+  declare type Options = Partial<{
     alias: string | Array<string>,
     array: boolean,
     boolean: boolean,

packages/metro-config/src/loadConfig.js

@@ -117,45 +117,56 @@ function mergeConfig<T: InputConfigT>(
 
       resolver: {
         ...totalConfig.resolver,
+        // $FlowFixMe[exponential-spread]
         ...(nextConfig.resolver || {}),
         dependencyExtractor:
           nextConfig.resolver && nextConfig.resolver.dependencyExtractor != null
             ? resolve(nextConfig.resolver.dependencyExtractor)
-            : totalConfig.resolver.dependencyExtractor,
+            : // $FlowFixMe[incompatible-use]
+              totalConfig.resolver.dependencyExtractor,
         hasteImplModulePath:
           nextConfig.resolver && nextConfig.resolver.hasteImplModulePath != null
             ? resolve(nextConfig.resolver.hasteImplModulePath)
-            : totalConfig.resolver.hasteImplModulePath,
+            : // $FlowFixMe[incompatible-use]
+              totalConfig.resolver.hasteImplModulePath,
       },
       serializer: {
         ...totalConfig.serializer,
+        // $FlowFixMe[exponential-spread]
         ...(nextConfig.serializer || {}),
       },
       transformer: {
         ...totalConfig.transformer,
+        // $FlowFixMe[exponential-spread]
         ...(nextConfig.transformer || {}),
         babelTransformerPath:
           nextConfig.transformer &&
           nextConfig.transformer.babelTransformerPath != null
             ? resolve(nextConfig.transformer.babelTransformerPath)
-            : totalConfig.transformer.babelTransformerPath,
+            : // $FlowFixMe[incompatible-use]
+              totalConfig.transformer.babelTransformerPath,
       },
       server: {
         ...totalConfig.server,
+        // $FlowFixMe[exponential-spread]
         ...(nextConfig.server || {}),
       },
       symbolicator: {
         ...totalConfig.symbolicator,
+        // $FlowFixMe[exponential-spread]
         ...(nextConfig.symbolicator || {}),
       },
       watcher: {
         ...totalConfig.watcher,
+        // $FlowFixMe[exponential-spread]
         ...nextConfig.watcher,
         watchman: {
+          // $FlowFixMe[exponential-spread]
           ...totalConfig.watcher?.watchman,
           ...nextConfig.watcher?.watchman,
         },
         healthCheck: {
+          // $FlowFixMe[exponential-spread]
           ...totalConfig.watcher?.healthCheck,
           // $FlowFixMe: Spreading shapes creates an explosion of union types
           ...nextConfig.watcher?.healthCheck,
@@ -180,16 +191,22 @@ async function loadMetroConfigFromDisk(
   const rootPath = dirname(filepath);
 
   const defaults = await getDefaultConfig(rootPath);
+  // $FlowFixMe[incompatible-variance]
+  // $FlowFixMe[incompatible-call]
   const defaultConfig: ConfigT = mergeConfig(defaults, defaultConfigOverrides);
 
   if (typeof configModule === 'function') {
     // Get a default configuration based on what we know, which we in turn can pass
     // to the function.
 
     const resultedConfig = await configModule(defaultConfig);
+    // $FlowFixMe[incompatible-call]
+    // $FlowFixMe[incompatible-variance]
     return mergeConfig(defaultConfig, resultedConfig);
   }
 
+  // $FlowFixMe[incompatible-variance]
+  // $FlowFixMe[incompatible-call]
   return mergeConfig(defaultConfig, configModule);
 }
 
@@ -207,10 +224,12 @@ function overrideConfigWithArguments(
   };
 
   if (argv.port != null) {
+    // $FlowFixMe[incompatible-use]
     output.server.port = Number(argv.port);
   }
 
   if (argv.runInspectorProxy != null) {
+    // $FlowFixMe[incompatible-use]
     output.server.runInspectorProxy = Boolean(argv.runInspectorProxy);
   }
 
@@ -223,14 +242,17 @@ function overrideConfigWithArguments(
   }
 
   if (argv.assetExts != null) {
+    // $FlowFixMe[incompatible-use]
     output.resolver.assetExts = argv.assetExts;
   }
 
   if (argv.sourceExts != null) {
+    // $FlowFixMe[incompatible-use]
     output.resolver.sourceExts = argv.sourceExts;
   }
 
   if (argv.platforms != null) {
+    // $FlowFixMe[incompatible-use]
     output.resolver.platforms = argv.platforms;
   }
 
@@ -239,6 +261,7 @@ function overrideConfigWithArguments(
   }
 
   if (argv.transformer != null) {
+    // $FlowFixMe[incompatible-use]
     output.transformer.babelTransformerPath = argv.transformer;
   }
 
@@ -255,6 +278,8 @@ function overrideConfigWithArguments(
     // TODO: Ask if this is the way to go
   }
 
+  // $FlowFixMe[incompatible-variance]
+  // $FlowFixMe[incompatible-call]
   return mergeConfig(config, output);
 }
 
@@ -298,6 +323,9 @@ async function loadConfig(
 
   // Set the watchfolders to include the projectRoot, as Metro assumes that is
   // the case
+  // $FlowFixMe[incompatible-variance]
+  // $FlowFixMe[incompatible-indexer]
+  // $FlowFixMe[incompatible-call]
   return mergeConfig(configWithArgs, overriddenConfig);
 }
 

packages/metro-transform-plugins/src/constant-folding-plugin.js

@@ -78,56 +78,62 @@ function constantFoldingPlugin(context: {
   const FunctionExpression: VisitNode<
     BabelNodeFunctionExpression | BabelNodeArrowFunctionExpression,
     State,
-  > = {
-    exit(path, state) {
-      const parentPath = path.parentPath;
-      const parentNode = parentPath?.node;
-
-      if (isVariableDeclarator(parentNode) && parentNode.id.name != null) {
-        const binding = parentPath?.scope.getBinding(parentNode.id.name);
-
-        if (binding && !binding.referenced) {
-          state.stripped = true;
-          parentPath?.remove();
+  > =
+    // $FlowFixMe[incompatible-type]
+    {
+      exit(path, state) {
+        const parentPath = path.parentPath;
+        const parentNode = parentPath?.node;
+
+        if (isVariableDeclarator(parentNode) && parentNode.id.name != null) {
+          const binding = parentPath?.scope.getBinding(parentNode.id.name);
+
+          if (binding && !binding.referenced) {
+            state.stripped = true;
+            parentPath?.remove();
+          }
         }
-      }
-    },
-  };
+      },
+    };
 
   const Conditional: VisitNode<
     BabelNodeIfStatement | BabelNodeConditionalExpression,
     State,
-  > = {
-    exit(path, state): void {
-      const node = path.node;
-      const result = evaluate(path.get('test'));
-
-      if (result.confident) {
-        state.stripped = true;
+  > =
+    // $FlowFixMe[incompatible-type]
+    {
+      exit(path, state): void {
+        const node = path.node;
+        const result = evaluate(path.get('test'));
+
+        if (result.confident) {
+          state.stripped = true;
 
-        if (result.value || node.alternate) {
-          // $FlowFixMe Flow error uncovered by typing Babel more strictly
-          path.replaceWith(result.value ? node.consequent : node.alternate);
-        } else if (!result.value) {
-          path.remove();
+          if (result.value || node.alternate) {
+            // $FlowFixMe Flow error uncovered by typing Babel more strictly
+            path.replaceWith(result.value ? node.consequent : node.alternate);
+          } else if (!result.value) {
+            path.remove();
+          }
         }
-      }
-    },
-  };
+      },
+    };
 
   const Expression: VisitNode<
     BabelNodeUnaryExpression | BabelNodeBinaryExpression,
     State,
-  > = {
-    exit(path) {
-      const result = evaluate(path);
-
-      if (result.confident) {
-        path.replaceWith(t.valueToNode(result.value));
-        path.skip();
-      }
-    },
-  };
+  > =
+    // $FlowFixMe[incompatible-type]
+    {
+      exit(path) {
+        const result = evaluate(path);
+
+        if (result.confident) {
+          path.replaceWith(t.valueToNode(result.value));
+          path.skip();
+        }
+      },
+    };
 
   const LogicalExpression = {
     exit(path: NodePath<BabelNodeLogicalExpression>) {
@@ -164,6 +170,7 @@ function constantFoldingPlugin(context: {
         {
           ArrowFunctionExpression: FunctionExpression,
           ConditionalExpression: Conditional,
+          // $FlowFixMe[incompatible-call]
           FunctionDeclaration,
           FunctionExpression,
           IfStatement: Conditional,
@@ -186,6 +193,7 @@ function constantFoldingPlugin(context: {
 
   const visitor: Visitor<State> = {
     BinaryExpression: Expression,
+    // $FlowFixMe[incompatible-type]
     LogicalExpression,
     Program: {...Program}, // Babel mutates objects passed.
     UnaryExpression: Expression,

packages/metro/src/DeltaBundler/__tests__/Graph-test.js

@@ -30,7 +30,7 @@ import {Graph} from '../Graph';
 
 const {objectContaining} = expect;
 
-type DependencyDataInput = $Shape<TransformResultDependency['data']>;
+type DependencyDataInput = Partial<TransformResultDependency['data']>;
 
 let mockedDependencies: Set<string> = new Set();
 let mockedDependencyTree: Map<
@@ -304,6 +304,7 @@ beforeEach(async () => {
             asyncType: null,
             // $FlowFixMe[missing-empty-array-annot]
             locs: [],
+            // $FlowFixMe[incompatible-call]
             key: dep.data.key,
             ...dep.data,
           },

packages/metro/src/index.flow.js

@@ -143,6 +143,8 @@ export type {MetroConfig};
 
 async function getConfig(config: InputConfigT): Promise<ConfigT> {
   const defaultConfig = await getDefaultConfig(config.projectRoot);
+  // $FlowFixMe[incompatible-variance]
+  // $FlowFixMe[incompatible-call]
   return mergeConfig(defaultConfig, config);
 }
 
@@ -198,6 +200,8 @@ const createConnectMiddleware = async function (
   config: ConfigT,
   options?: RunMetroOptions,
 ): Promise<MetroMiddleWare> {
+  // $FlowFixMe[incompatible-variance]
+  // $FlowFixMe[incompatible-call]
   const metroServer = await runMetro(config, options);
 
   let enhancedMiddleware: Middleware = metroServer.processRequest;
@@ -392,6 +396,8 @@ exports.runBuild = async (
   map: string,
   ...
 }> => {
+  // $FlowFixMe[incompatible-variance]
+  // $FlowFixMe[incompatible-call]
   const metroServer = await runMetro(config, {
     watch: false,
   });