Support non-constructor JSX factory functions

TypeScript Version: 3.3.3 to 3.8.3

Search Terms:
jsx factory function constructor component ElementClass

Expected behavior:
I'm trying to pass a factory function instead of a class component as a JSX element constructor function. It should be possible according to the Handbook, as described here. See the example under the Type checking -> class component section (I can't deep-link with hash/anchor because the server isn't properly configured :( ). I should get no errors with the code provided below.

Actual behavior:
I get the following error:

JSX element type '{ render: () => { custom: string; }; }' is not a constructor function for JSX elements.
  Property 'custom' is missing in type '{ render: () => { custom: string; }; }' but required in type 'Element'.(2605)

From what I can tell, this used to work, but the behavior broke somewhere between v3.1.6 and v3.3.3 (as tried in the Playground). I'm guessing there was some change that altered detection between React function components and class components and that change introduced this bug. I'm not even sure if React runtime even allows factory functions, but my use case is a custom library and I'm not using React at all. This error is the same regardless of using React or not.

Also, with the exact example from the Handbook, because the JSX.Element is not specified explicitly, there is no error, even when there should be one. See Playground Link for Handbook example

Related Issues:
https://github.com/microsoft/TypeScript/issues/5740
https://github.com/microsoft/TypeScript/issues/5478

Code

declare namespace JSX {
  interface Element {
    custom: string;
  }
  interface ElementClass {
    render: () => Element;
  }
}

class MyComponent {
  render() {
    return {
      custom: "2"
    };
  }
}
function MyFactoryFunction() {
  return { render: () => { return { custom: "2" }; } }
}
function MyFunctionComponent() {
  return { custom: "2" }
}

<MyComponent />; // ok
<MyFactoryFunction />; // ok
<MyFunctionComponent />; // ok

class NotAValidComponent {}
function NotAValidFactoryFunction() {
  return {};
}

<NotAValidComponent />; // error
<NotAValidFactoryFunction />; // error

"use strict";
class MyComponent {
    render() {
        return {
            custom: "2"
        };
    }
}
function MyFactoryFunction() {
    return { render: () => { return { custom: "2" }; } };
}
function MyFunctionComponent() {
    return { custom: "2" };
}
<MyComponent />; // ok
<MyFactoryFunction />; // ok
<MyFunctionComponent />; // ok
class NotAValidComponent {
}
function NotAValidFactoryFunction() {
    return {};
}
<NotAValidComponent />; // error
<NotAValidFactoryFunction />; // error

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictPropertyInitialization": true,
    "strictBindCallApply": true,
    "noImplicitThis": true,
    "noImplicitReturns": true,
    "useDefineForClassFields": false,
    "alwaysStrict": true,
    "allowUnreachableCode": false,
    "allowUnusedLabels": false,
    "downlevelIteration": false,
    "noEmitHelpers": false,
    "noLib": false,
    "noStrictGenericChecks": false,
    "noUnusedLocals": false,
    "noUnusedParameters": false,
    "esModuleInterop": true,
    "preserveConstEnums": false,
    "removeComments": false,
    "skipLibCheck": false,
    "checkJs": false,
    "allowJs": false,
    "declaration": true,
    "experimentalDecorators": false,
    "emitDecoratorMetadata": false,
    "target": "ES2017",
    "module": "ESNext"
  }
}

Playground Link: Provided

Comienza con el reproductor JSX proporcionado y compara su comportamiento entre las versiones de TypeScript indicadas. Rastrea cómo se distinguen los JSX class components, las factory functions y las function components, y añade cobertura que demuestre que las factory functions válidas y las factory functions no válidas reciben los diagnostics esperados.