[Dep] upgrade to Recast from 0.20.4 to 0.23.4

**What?**
Upgrade [recast](https://github.com/benjamn/recast) from `0.20.4` to `0.23.4` for more modern parsers. See [changes](benjamn/[email protected]).

As part of the upgrade, the `[email protected]` patch is removed as it is no longer needed.

**Why?**

When the codemod with `[email protected]` removes comments, the parentheses can be incorrectly removed.

Upgrading to `[email protected]` fixes this.

For example, the following Flow type:
```js
const a =
  // $FlowFixMe
  (1 + 1) * 2;
```
was incorrectly converted to:
```ts
const a = 1 + 1 * 2;
```

With the new version, it gets correctly converted to:
```ts
const a = (1 + 1) * 2;
```

Also, codemod with `[email protected]` keeps the following annotation as is:
```js
type Props = {
  it: string,
  foo: number
};
````

With [this fix](benjamn/recast#1157) from v0.21.2, the Flow syntax gets correctly converted to the expected TypeScript syntax:

```ts
type Props = {
  it: string;
  foo: number;
};
```

Lastly, v0.23.4 correctly handles unary expressions by [wrapping unary expressions in parens](benjamn/recast#1361)

Author: jackhsu978

package.json

@@ -65,7 +65,7 @@
     "jest-junit": "^12.0.0",
     "patch-package": "^6.4.7",
     "prettier": "^2.4.1",
-    "recast": "^0.20.4",
+    "recast": "0.23.4",
     "signale": "^1.4.0",
     "ts-jest": "^26.0.0",
     "ts-morph": "^13.0.2",

patches/recast+0.20.4.patch

@@ -276,7 +276,7 @@ describe("transform declarations", () => {
   it("converts more complicated $Exact types", async () => {
     const src = dedent`type Test = $Exact<T | { foo: string }>;`;
     const expected = dedent`type Test = T | {
-      foo: string
+      foo: string;
     };`;
     expect(await transform(src)).toBe(expected);
   });
@@ -504,7 +504,7 @@ describe("transform declarations", () => {
   it("Converts React.Node to React.ReactNode in Props", async () => {
     const src = `type Props = {children?: React.Node};`;
     const expected = dedent`type Props = {
-      children?: React.ReactNode
+      children?: React.ReactNode;
     };`;
     expect(await transform(src)).toBe(expected);
   });
@@ -739,21 +739,6 @@ describe("transform declarations", () => {
       `;
       expect(await transform(src)).toBe(expected);
     });
-    it("when a comment is in a type param declaration, it should preserve the newline", async () => {
-      const src = dedent`
-      const AThing: Array<
-      // FlowFixMe
-      number> = []
-      `;
-
-      const expected = dedent`
-      const AThing: Array<
-      // FlowFixMe
-      number> = []
-      `;
-
-      expect(await transform(src)).toBe(expected);
-    });
   });
 
   describe("for opaque types", () => {

src/convert/declarations.test.ts

@@ -126,7 +126,7 @@ describe("transform expressions", () => {
       |}> = new Array(0);`;
       const expected = dedent`
       const a: Array<{
-        foo: 'bar'
+        foo: 'bar';
       }> = new Array(0);`;
       expect(await transform(src)).toBe(expected);
     });
@@ -140,18 +140,23 @@ describe("transform expressions", () => {
       const expected = dedent`
       const test = () => {
         return class extends React.Component<Record<any, any>, {
-          bar: string
+          bar: string;
         }> {};
       };`;
       expect(await transform(src)).toBe(expected);
     });
 
-    it("should not change if there are no exact bars", async () => {
-      const expected = dedent`
+    it("should only add semicolon if there are no exact bars", async () => {
+      const src = dedent`
+      // @flow
       const a: Array<{
         foo: 'bar'
       }> = new Array(0);`;
-      expect(await transform(expected)).toBe(expected);
+      const expected = dedent`
+      const a: Array<{
+        foo: 'bar';
+      }> = new Array(0);`;
+      expect(await transform(src)).toBe(expected);
     });
 
     it("should remove the exact object types from constructed objects", async () => {
@@ -161,7 +166,7 @@ describe("transform expressions", () => {
       |}>();`;
       const expected = dedent`
       const a = new Array<{
-        foo: 'bar'
+        foo: 'bar';
       }>();`;
       expect(await transform(src)).toBe(expected);
     });

src/convert/expressions.test.ts

@@ -22,8 +22,8 @@ describe("transform spread JSX attributes", () => {
     const expected = `
     import {Flow} from 'flow-to-typescript-codemod';
     type Props = {
-      it: string,
-      foo: number
+      it: string;
+      foo: number;
     };
 
     function Foobar(x: Props & Omit<Omit<Flow.ComponentProps<typeof Mine>, 'it'>, keyof Props>) { 
@@ -51,8 +51,8 @@ describe("transform spread JSX attributes", () => {
     const expected = `
     import {Flow} from 'flow-to-typescript-codemod';
     type Props = {
-      it: string,
-      foo: number
+      it: string;
+      foo: number;
     };
 
     const Foobar = (x: Props & Omit<Omit<Flow.ComponentProps<typeof Mine>, 'it'>, keyof Props>) => { 
@@ -84,8 +84,8 @@ describe("transform spread JSX attributes", () => {
     const expected = `
     import {Flow} from 'flow-to-typescript-codemod';
     type Props = {
-      it: string,
-      foo: number
+      it: string;
+      foo: number;
     };
 
     function Foobar(x: Props & Omit<Omit<Flow.ComponentProps<typeof Mine>, 'it'>, keyof Props>) { 
@@ -121,8 +121,8 @@ describe("transform spread JSX attributes", () => {
     const expected = `
     import {Flow} from 'flow-to-typescript-codemod';
     type Props = {
-      it: string,
-      foo: number
+      it: string;
+      foo: number;
     };
 
     class MyComponent extends React.Component<Props & Omit<Omit<Flow.ComponentProps<typeof Mine>, 'it'>, keyof Props>> {
@@ -157,8 +157,8 @@ describe("transform spread JSX attributes", () => {
     const expected = `
     import {Flow} from 'flow-to-typescript-codemod';
     type Props = {
-      it: string,
-      foo: number
+      it: string;
+      foo: number;
     };
 
     class MyComponent extends React.Component<Props & Omit<Omit<Flow.ComponentProps<typeof Mine>, 'it'>, keyof Props>> {
@@ -192,8 +192,8 @@ describe("transform spread JSX attributes", () => {
 
     const expected = `
     type Props = {
-      it: string,
-      foo: number
+      it: string;
+      foo: number;
     };
 
     class MyComponent extends React.Component<Props> {
@@ -228,11 +228,11 @@ describe("transform spread JSX attributes", () => {
     const expected = `
     import {Flow} from 'flow-to-typescript-codemod';
     type State = {
-      thing: boolean
+      thing: boolean;
     };
     type Props = {
-      it: string,
-      foo: number
+      it: string;
+      foo: number;
     };
 
     class MyComponent extends React.Component<Props & Omit<Omit<Flow.ComponentProps<typeof Mine>, 'it'>, keyof Props>, State> {
@@ -263,8 +263,8 @@ describe("transform spread JSX attributes", () => {
     const expected = `
     import {Flow} from 'flow-to-typescript-codemod';
     type Props = {
-      it: string,
-      foo: number
+      it: string;
+      foo: number;
     };
 
     function Foobar(x: Props & Omit<Flow.ComponentProps<typeof Mine>, keyof Props>) { 
@@ -292,8 +292,8 @@ describe("transform spread JSX attributes", () => {
     }`;
     const expected = `
     type Props = {
-      it: string,
-      foo: number
+      it: string;
+      foo: number;
     };
 
     function Foobar(x: Props) { 

src/convert/jsx-spread/jsx-spread.test.ts

@@ -158,15 +158,15 @@ describe("transform type annotations", () => {
   it("Does not convert string Object key types to records", async () => {
     const src = `const MyObj: {[key: string]: ValueType} = {};`;
     const expected = dedent`const MyObj: {
-      [key: string]: ValueType
+      [key: string]: ValueType;
     } = {};`;
     expect(await transform(src)).toBe(expected);
   });
 
   it("Does not convert number Object key types to records", async () => {
     const src = `const MyObj: {[key: number]: ValueType} = {};`;
     const expected = dedent`const MyObj: {
-      [key: number]: ValueType
+      [key: number]: ValueType;
     } = {};`;
     expect(await transform(src)).toBe(expected);
   });
@@ -323,7 +323,7 @@ describe("transform type annotations", () => {
     `;
     const expected = dedent`
     type MockApiOptions = {
-      errors: jest.MockedFunction<any>
+      errors: jest.MockedFunction<any>;
     };
     `;
     expect(await transform(src)).toBe(expected);
@@ -342,7 +342,7 @@ describe("transform type annotations", () => {
       startDate: moment
     };`;
     const expected = dedent`type Test = {
-      startDate: moment.Moment
+      startDate: moment.Moment;
     };`;
     expect(await transform(src)).toBe(expected);
   });
@@ -532,7 +532,7 @@ describe("transform type annotations", () => {
     };`;
     const expected = dedent`
     type Props = {
-      children: Array<MenuChildren> | MenuChildren
+      children: Array<MenuChildren> | MenuChildren;
     };`;
     expect(await transform(src)).toBe(expected);
   });
@@ -595,14 +595,14 @@ describe("transform type annotations", () => {
     it("Does not convert {} to Record<any, any> if an object has any properties", async () => {
       // dedent messes up the indentation of the string
       const src = `function f(): {
-  prop: boolean
+  prop: boolean;
 } {return {}}
 let af: () => {
-  prop: boolean
+  prop: boolean;
 }
 class C {
   m(): {
-    prop: boolean
+    prop: boolean;
   } {return {}}
 }`;
 
@@ -764,9 +764,9 @@ class C {
 
     const expected = dedent`
     export type Test = {
-      <T>(arg1: undefined | Example | Example[], arg2?: () => T | null | undefined): T,
-      (arg1: undefined | Example | Example[]): Attributes,
-      foo: number
+      <T>(arg1: undefined | Example | Example[], arg2?: () => T | null | undefined): T;
+      (arg1: undefined | Example | Example[]): Attributes;
+      foo: number;
     };
     `;
     expect(await transform(src)).toBe(expected);
@@ -783,9 +783,9 @@ class C {
 
     const expected = dedent`
     type Test = {
-      <T>(arg1: undefined | Example | Example[], arg2?: () => T | null | undefined): T,
-      (arg1: undefined | Example | Example[]): Attributes,
-      foo: number
+      <T>(arg1: undefined | Example | Example[], arg2?: () => T | null | undefined): T;
+      (arg1: undefined | Example | Example[]): Attributes;
+      foo: number;
     };
     `;
     expect(await transform(src)).toBe(expected);