Remove handling of ExpressionStatments and add type hints for TypeScript

`__reactBuiltinTypeHint` is added so that Typescript does not think it is
just a CallExpression, because in reality we check for way more than if
it is just a CallExpression. Adding that hint makes TypeScript realize that
even though the `isSomething()` helper returned false it might still
be a CallExpression.

Author: danez

Diff for: packages/react-docgen/src/handlers/componentDocblockHandler.ts

@@ -39,7 +39,7 @@ function getDocblockFromComponent(path: NodePath): string | null {
   }
   if (!description) {
     const searchPath = isReactForwardRefCall(path)
-      ? path.get('arguments')[0]
+      ? path.get('arguments')[0]!
       : path;
     const inner = resolveToValue(searchPath);
 

Diff for: packages/react-docgen/src/handlers/componentMethodsHandler.ts

@@ -141,7 +141,7 @@ function findStatelessComponentBody(
       return body;
     }
   } else if (isReactForwardRefCall(componentDefinition)) {
-    const inner = resolveToValue(componentDefinition.get('arguments')[0]);
+    const inner = resolveToValue(componentDefinition.get('arguments')[0]!);
 
     return findStatelessComponentBody(inner);
   }

Diff for: packages/react-docgen/src/handlers/defaultPropsHandler.ts

@@ -60,7 +60,7 @@ function getStatelessPropsPath(
   let value = resolveToValue(componentDefinition);
 
   if (isReactForwardRefCall(value)) {
-    value = resolveToValue(value.get('arguments')[0]);
+    value = resolveToValue(value.get('arguments')[0]!);
   }
 
   return value.get('params')[0];

Diff for: packages/react-docgen/src/utils/__tests__/isExportsOrModuleAssignment-test.ts

@@ -5,19 +5,19 @@ import { describe, expect, test } from 'vitest';
 describe('isExportsOrModuleAssignment', () => {
   test('detects "module.exports = ...;"', () => {
     expect(
-      isExportsOrModuleAssignment(parse.statement('module.exports = foo;')),
+      isExportsOrModuleAssignment(parse.expression('module.exports = foo')),
     ).toBe(true);
   });
 
   test('detects "exports.foo = ..."', () => {
     expect(
-      isExportsOrModuleAssignment(parse.statement('exports.foo = foo;')),
+      isExportsOrModuleAssignment(parse.expression('exports.foo = foo')),
     ).toBe(true);
   });
 
   test('does not accept "exports = foo;"', () => {
     // That doesn't actually export anything
-    expect(isExportsOrModuleAssignment(parse.statement('exports = foo;'))).toBe(
+    expect(isExportsOrModuleAssignment(parse.expression('exports = foo'))).toBe(
       false,
     );
   });

Diff for: packages/react-docgen/src/utils/findComponentDefinition.ts

@@ -24,7 +24,7 @@ function resolveComponentDefinition(
 ): NodePath<ComponentNode> | null {
   if (isReactCreateClassCall(definition)) {
     // return argument
-    const resolvedPath = resolveToValue(definition.get('arguments')[0]);
+    const resolvedPath = resolveToValue(definition.get('arguments')[0]!);
 
     if (resolvedPath.isObjectExpression()) {
       return resolvedPath;

Diff for: packages/react-docgen/src/utils/getTypeFromReactComponent.ts

@@ -30,7 +30,7 @@ function getStatelessPropsPath(
   let value = resolveToValue(componentDefinition);
 
   if (isReactForwardRefCall(value)) {
-    value = resolveToValue(value.get('arguments')[0]);
+    value = resolveToValue(value.get('arguments')[0]!);
   }
 
   if (!value.isFunction()) return;

Diff for: packages/react-docgen/src/utils/isExportsOrModuleAssignment.ts

@@ -6,9 +6,6 @@ import * as expressionTo from './expressionTo.js';
  * `modules.exports = ...;`.
  */
 export default function isExportsOrModuleAssignment(path: NodePath): boolean {
-  if (path.isExpressionStatement()) {
-    path = path.get('expression');
-  }
   if (
     !path.isAssignmentExpression() ||
     !path.get('left').isMemberExpression()

Diff for: packages/react-docgen/src/utils/isReactBuiltinCall.ts

@@ -46,11 +46,7 @@ function isNamedImportDeclaration(
 export default function isReactBuiltinCall(
   path: NodePath,
   name: string,
-): boolean {
-  if (path.isExpressionStatement()) {
-    path = path.get('expression');
-  }
-
+): path is NodePath<CallExpression & { __reactBuiltinTypeHint: true }> {
   if (path.isCallExpression()) {
     const callee = path.get('callee');
 

Diff for: packages/react-docgen/src/utils/isReactChildrenElementCall.ts

@@ -1,16 +1,15 @@
 import type { NodePath } from '@babel/traverse';
 import isReactModuleName from './isReactModuleName.js';
 import resolveToModule from './resolveToModule.js';
+import { CallExpression } from '@babel/types';
 
 /**
  * Returns true if the expression is a function call of the form
  * `React.Children.only(...)` or `React.Children.map(...)`.
  */
-export default function isReactChildrenElementCall(path: NodePath): boolean {
-  if (path.isExpressionStatement()) {
-    path = path.get('expression');
-  }
-
+export default function isReactChildrenElementCall(
+  path: NodePath,
+): path is NodePath<CallExpression & { __reactBuiltinTypeHint: true }> {
   if (!path.isCallExpression()) {
     return false;
   }

Diff for: packages/react-docgen/src/utils/isReactCloneElementCall.ts

@@ -1,13 +1,13 @@
 import type { NodePath } from '@babel/traverse';
-import type { Expression, ExpressionStatement } from '@babel/types';
+import type { CallExpression } from '@babel/types';
 import isReactBuiltinCall from './isReactBuiltinCall.js';
 
 /**
  * Returns true if the expression is a function call of the form
  * `React.cloneElement(...)`.
  */
 export default function isReactCloneElementCall(
-  path: NodePath<Expression | ExpressionStatement>,
-): boolean {
+  path: NodePath,
+): path is NodePath<CallExpression & { __reactBuiltinTypeHint: true }> {
   return isReactBuiltinCall(path, 'cloneElement');
 }

Diff for: packages/react-docgen/src/utils/isReactCreateClassCall.ts

@@ -1,6 +1,7 @@
 import type { NodePath } from '@babel/traverse';
 import resolveToModule from './resolveToModule.js';
 import isReactBuiltinCall from './isReactBuiltinCall.js';
+import { CallExpression } from '@babel/types';
 
 /**
  * Returns true if the expression is a function call of the form
@@ -10,10 +11,6 @@ import isReactBuiltinCall from './isReactBuiltinCall.js';
  * ```
  */
 function isReactCreateClassCallModular(path: NodePath): boolean {
-  if (path.isExpressionStatement()) {
-    path = path.get('expression');
-  }
-
   if (!path.isCallExpression()) {
     return false;
   }
@@ -30,9 +27,12 @@ function isReactCreateClassCallModular(path: NodePath): boolean {
  * createReactClass(...);
  * ```
  */
-export default function isReactCreateClassCall(path: NodePath): boolean {
+export default function isReactCreateClassCall(
+  path: NodePath,
+): path is NodePath<CallExpression & { __reactBuiltinTypeHint: true }> {
   return (
-    isReactBuiltinCall(path, 'createClass') ||
+    (isReactBuiltinCall(path, 'createClass') &&
+      path.get('arguments').length === 1) ||
     isReactCreateClassCallModular(path)
   );
 }

Diff for: packages/react-docgen/src/utils/isReactCreateElementCall.ts

@@ -1,13 +1,13 @@
 import type { NodePath } from '@babel/traverse';
-import type { Expression, ExpressionStatement } from '@babel/types';
+import type { CallExpression } from '@babel/types';
 import isReactBuiltinCall from './isReactBuiltinCall.js';
 
 /**
  * Returns true if the expression is a function call of the form
  * `React.createElement(...)`.
  */
 export default function isReactCreateElementCall(
-  path: NodePath<Expression | ExpressionStatement>,
-): boolean {
+  path: NodePath,
+): path is NodePath<CallExpression & { __reactBuiltinTypeHint: true }> {
   return isReactBuiltinCall(path, 'createElement');
 }

Diff for: packages/react-docgen/src/utils/isReactForwardRefCall.ts

@@ -1,10 +1,16 @@
 import type { NodePath } from '@babel/traverse';
 import isReactBuiltinCall from './isReactBuiltinCall.js';
+import { CallExpression } from '@babel/types';
 
 /**
  * Returns true if the expression is a function call of the form
  * `React.forwardRef(...)`.
  */
-export default function isReactForwardRefCall(path: NodePath): boolean {
-  return isReactBuiltinCall(path, 'forwardRef');
+export default function isReactForwardRefCall(
+  path: NodePath,
+): path is NodePath<CallExpression & { __reactBuiltinTypeHint: true }> {
+  return (
+    isReactBuiltinCall(path, 'forwardRef') &&
+    (path as NodePath<CallExpression>).get('arguments').length === 1
+  );
 }