fix: remove typeof from instanceOf and symbol prop types

Author: unstubbable

Diff for: src/analyzer.ts

@@ -80,9 +80,8 @@ export function getTypeFromPropType(node: IASTNode, instanceOfResolver = default
         break;
       case 'instanceOf':
         if (type.importPath) {
-          result.type = 'typeof ' + type.type;
-          (result as any).importType = type.type;
-          (result as any).importPath = type.importPath;
+          result.type = type.type;
+          result.importPath = type.importPath;
         } else {
           result.type = 'any';
         }

Diff for: src/deprecated.ts

@@ -13,7 +13,6 @@ export enum ExportType {
 export interface IProp {
   type: string;
   optional: boolean;
-  importType?: string;
   importPath?: string;
   documentation?: string;
 }
@@ -36,8 +35,8 @@ function deprecatedGenerator(generator: Generator, moduleName: string|null,
     if (propTypes) {
       Object.keys(propTypes).forEach(propName => {
         const prop = propTypes[propName];
-        if (prop.importType && prop.importPath) {
-          generator.import(prop.importType, prop.importPath);
+        if (prop.importPath) {
+          generator.import(prop.type, prop.importPath);
         }
       });
     }

Diff for: src/types.ts

@@ -69,7 +69,7 @@ function getSimpleType(ast: AstQuery, propertyAst: any,
     case 'element':
       return getTypeDeclaration(dom.create.namedTypeReference('React.ReactElement<any>'), !required);
     case 'symbol':
-      return getTypeDeclaration(dom.create.typeof(dom.create.namedTypeReference('Symbol')), !required);
+      return getTypeDeclaration(dom.create.namedTypeReference('Symbol'), !required);
   }
   return undefined;
 }
@@ -79,8 +79,7 @@ function getComplexType(ast: AstQuery, propertyAst: any,
   const [required, complexTypeName, typeAst] = getComplexTypeName(ast, propertyAst, importedPropTypes);
   switch (complexTypeName) {
     case 'instanceOf':
-      return getTypeDeclaration(dom.create.typeof(
-        dom.create.namedTypeReference(typeAst.arguments[0].name)), !required);
+      return getTypeDeclaration(dom.create.namedTypeReference(typeAst.arguments[0].name), !required);
     case 'oneOfType':
       const typeDecls = typeAst.arguments[0].elements
         .map((subtree: any) => get(ast, subtree, importedPropTypes, options)) as TypeDeclaration[];

Diff for: tests/es6-class.d.ts

@@ -38,7 +38,7 @@ declare module 'component' {
     optionalString?: string;
     optionalNode?: React.ReactNode;
     optionalElement?: React.ReactElement<any>;
-    optionalMessage?: typeof Message;
+    optionalMessage?: Message;
     optionalEnum?: ComponentOptionalEnum;
     optionalUnion?: ComponentOptionalUnion;
     optionalArrayOf?: number[];
@@ -49,7 +49,7 @@ declare module 'component' {
     requiredArrayOf: string[];
     requiredArrayOfObjectsWithShape: ComponentRequiredArrayOfObjectsWithShape[];
     deeplyNested: ComponentDeeplyNested[];
-    requiredSymbol: typeof Symbol;
+    requiredSymbol: Symbol;
   }
 
   export class Component extends Component<ComponentProps, any> {

Diff for: tests/es7-class-babeled-to-es6.d.ts

@@ -38,7 +38,7 @@ declare module 'component' {
     optionalString?: string;
     optionalNode?: React.ReactNode;
     optionalElement?: React.ReactElement<any>;
-    optionalMessage?: typeof Message;
+    optionalMessage?: Message;
     optionalEnum?: MyComponentOptionalEnum;
     optionalUnion?: MyComponentOptionalUnion;
     optionalArrayOf?: number[];
@@ -49,7 +49,7 @@ declare module 'component' {
     requiredArrayOf: string[];
     requiredArrayOfObjectsWithShape: MyComponentRequiredArrayOfObjectsWithShape[];
     deeplyNested: MyComponentDeeplyNested[];
-    requiredSymbol: typeof Symbol;
+    requiredSymbol: Symbol;
   }
 
   export class MyComponent extends Component<MyComponentProps, any> {

Diff for: tests/es7-class-top-level-module.d.ts

@@ -18,7 +18,7 @@ export interface ComponentProps {
   optionalString?: string;
   optionalNode?: React.ReactNode;
   optionalElement?: React.ReactElement<any>;
-  optionalMessage?: typeof Message;
+  optionalMessage?: Message;
   optionalUnion?: ComponentOptionalUnion;
   optionalArrayOf?: number[];
   requiredFunc: (...args: any[]) => any;

Diff for: tests/es7-class.d.ts

@@ -19,7 +19,7 @@ declare module 'component' {
     optionalString?: string;
     optionalNode?: React.ReactNode;
     optionalElement?: React.ReactElement<any>;
-    optionalMessage?: typeof Message;
+    optionalMessage?: Message;
     optionalUnion?: ComponentOptionalUnion;
     optionalArrayOf?: number[];
     requiredFunc: (...args: any[]) => any;

Diff for: tests/instance-of-proptype-names.d.ts

@@ -3,7 +3,7 @@ declare module 'component' {
   import Member from './member';
 
   export interface TestProps {
-    test?: typeof Member;
+    test?: Member;
   }
 
   export class Test extends Component<TestProps, any> {

Diff for: tests/parse-prop-types-test.ts

@@ -233,7 +233,7 @@ test('The PropType parser should return number|string for' +
   t.is(result.type, 'number|string');
   t.is(result.optional, true);
 });
-test('The PropType parser should return typeof Message for instanceOf(Message) prop types', t => {
+test('The PropType parser should return Message for instanceOf(Message) prop types', t => {
   const ast: any = {
     type: 'CallExpression',
     loc: {},
@@ -254,9 +254,8 @@ test('The PropType parser should return typeof Message for instanceOf(Message) p
     ]
   };
   const result: IProp = getTypeFromPropType(ast, (): string => './some/path');
-  t.is(result.type, 'typeof Message');
+  t.is(result.type, 'Message');
   t.is(result.optional, true);
-  t.is(result.importType, 'Message');
   t.is(result.importPath, './some/path');
 });
 test('The PropType parser should return any for unresolved instanceOf(Message) prop types', t => {
@@ -282,6 +281,5 @@ test('The PropType parser should return any for unresolved instanceOf(Message) p
   const result: IProp = getTypeFromPropType(ast);
   t.is(result.type, 'any');
   t.is(result.optional, true);
-  t.is(result.importType, undefined);
   t.is(result.importPath, undefined);
 });