fix: fix and improve error output

Author: KnisterPeter

package.json

@@ -46,7 +46,6 @@
     "babel-core": "6.23.1",
     "babel-preset-es2015": "6.18.0",
     "babel-register": "6.18.0",
-    "chalk": "1.1.3",
     "chokidar-cli": "1.2.0",
     "conventional-changelog-cli": "1.2.0",
     "coveralls": "^2.11.15",
@@ -65,10 +64,12 @@
     "astq": "2.0.0",
     "babel-generator": "6.23.0",
     "babylon": "6.16.1",
+    "chalk": "1.1.3",
     "dts-dom": "0.1.15",
     "get-stdin": "5.0.1",
     "meow": "3.7.0",
-    "pascal-case": "2.0.0"
+    "pascal-case": "2.0.0",
+    "strip-ansi": "3.0.1"
   },
   "config": {
     "commitizen": {

src/index.ts

@@ -29,6 +29,24 @@ export interface Options {
    * @deprecated
    */
   generator?: Generator;
+
+  /**
+   * Could be given if the generator is started with an AST.
+   *
+   * This is helpful to create better messages in case of errors/warnings.
+   *
+   * @type {string}
+   * @memberOf Options
+   */
+  source?: string;
+
+  /**
+   * Could be given to show filename in error/warning messages.
+   *
+   * @type {string}
+   * @memberOf Options
+   */
+  filename?: string;
 }
 
 export function cli(options: any): void {
@@ -41,7 +59,10 @@ export function cli(options: any): void {
   });
 }
 
-export function generateFromFile(moduleName: string|null, path: string, options?: IOptions): string {
+export function generateFromFile(moduleName: string|null, path: string, options: IOptions = {}): string {
+  if (!options.filename) {
+    options.filename = path;
+  }
   return generateFromSource(moduleName, fs.readFileSync(path).toString(), options);
 }
 
@@ -68,12 +89,15 @@ export function generateFromSource(moduleName: string|null, code: string, option
       'functionSent'
     ]
   });
+  if (!options.source) {
+    options.source = code;
+  }
   return generateFromAst(moduleName, ast, options);
 }
 
 export function generateFromAst(moduleName: string|null, ast: any, options: IOptions = {}): string {
   if (options.generator) {
     return generateTypings(moduleName, ast, options);
   }
-  return createTypings(moduleName, ast, options.instanceOfResolver);
+  return createTypings(moduleName, ast, options);
 }

src/types.ts

@@ -1,5 +1,7 @@
 import astToCode from 'babel-generator';
+import * as chalk from 'chalk';
 import * as dom from 'dts-dom';
+import { IOptions } from './index';
 import { propTypeQueryExpression, AstQuery } from './typings';
 
 export interface TypeDeclaration {
@@ -14,22 +16,22 @@ function getTypeDeclaration(type: any, optional: boolean): TypeDeclaration {
   };
 }
 
-export function get(ast: AstQuery, propertyAst: any, propTypesName: string|undefined): TypeDeclaration {
+export function get(ast: AstQuery, propertyAst: any, propTypesName: string|undefined,
+    options: IOptions): TypeDeclaration {
   try {
     const simpleType = getSimpleType(ast, propertyAst, propTypesName);
     if (simpleType) {
       return simpleType;
     }
-    const complexType = getComplexType(ast, propertyAst, propTypesName);
+    const complexType = getComplexType(ast, propertyAst, propTypesName, options);
     if (complexType) {
       return complexType;
     }
   } catch (e) {
-    console.error('Failed to infer PropType; Fallback to any');
     if (e.loc) {
-      const src = astToCode(ast.ast).code;
-      console.error(`Line ${e.loc.start.line}: ${src.split('\n')[e.loc.start.line - 1]}`);
+      printErrorWithContext(e, ast.ast, options);
     } else {
+      console.error('Failed to infer PropType; Fallback to any');
       console.error(e.stack);
     }
   }
@@ -73,18 +75,18 @@ function getSimpleType(ast: AstQuery, propertyAst: any,
 }
 
 function getComplexType(ast: AstQuery, propertyAst: any,
-    propTypesName: string|undefined): TypeDeclaration|undefined {
+    propTypesName: string|undefined, options: IOptions): TypeDeclaration|undefined {
   const [required, complexTypeName, typeAst] = getComplexTypeName(ast, propertyAst, propTypesName);
   switch (complexTypeName) {
     case 'instanceOf':
       return getTypeDeclaration(dom.create.typeof(
         dom.create.namedTypeReference(typeAst.arguments[0].name)), !required);
     case 'oneOfType':
       const typeDecls = typeAst.arguments[0].elements
-        .map((subtree: any) => get(ast, subtree, propTypesName)) as TypeDeclaration[];
+        .map((subtree: any) => get(ast, subtree, propTypesName, options)) as TypeDeclaration[];
       return getTypeDeclaration(dom.create.union(typeDecls.map(type => type.type)), !required);
     case 'arrayOf':
-      const typeDecl = get(ast, typeAst.arguments[0], propTypesName);
+      const typeDecl = get(ast, typeAst.arguments[0], propTypesName, options);
       return getTypeDeclaration(dom.create.array(typeDecl.type), !required);
     case 'oneOf':
       // tslint:disable:next-line comment-format
@@ -93,7 +95,7 @@ function getComplexType(ast: AstQuery, propertyAst: any,
       return getTypeDeclaration(dom.create.union(enumEntries as dom.Type[]), !required);
     case 'shape':
       const entries = getShapeProperties(ast, typeAst.arguments[0]).map((entry: any) => {
-        const typeDecl = get(ast, entry.value, propTypesName);
+        const typeDecl = get(ast, entry.value, propTypesName, options);
         return dom.create.property(entry.key.name, typeDecl.type,
           typeDecl.optional ? dom.DeclarationFlags.Optional : dom.DeclarationFlags.None);
       });
@@ -144,16 +146,12 @@ function getEnumValues(ast: AstQuery, oneOfTypes: any): any[] {
       /:init *
     `);
     if (!res[0]) {
-      const error = new Error('Failed to lookup enum values');
-      (error as any).loc = oneOfTypes.loc;
-      throw error;
+      throwWithLocation('Failed to lookup enum values', oneOfTypes);
     }
     oneOfTypes = res[0];
   }
   if (!oneOfTypes.elements) {
-    const error = new Error('Failed to lookup enum values');
-    (error as any).loc = oneOfTypes.loc;
-    throw error;
+    throwWithLocation('Failed to lookup enum values', oneOfTypes);
   }
   return (oneOfTypes.elements as any[]).map((element: any) => {
     // fixme: This are not named references!
@@ -178,14 +176,33 @@ function getShapeProperties(ast: AstQuery, input: any): any[] {
     if (res[0]) {
       return res[0].properties;
     }
-    const error = new Error('Failed to lookup shape properties');
-    (error as any).loc = input.loc;
-    throw error;
+    throwWithLocation('Failed to lookup shape properties', input);
   }
   if (!input.properties) {
-    const error = new Error('Failed to lookup shape properties');
-    (error as any).loc = input.loc;
-    throw error;
+    throwWithLocation('Failed to lookup shape properties', input);
   }
   return input.properties;
 }
+
+function throwWithLocation(message: string, ast: any): never {
+  const error = new Error(message);
+  (error as any).loc = ast.loc;
+  (error as any).start = ast.start;
+  (error as any).end = ast.end;
+  throw error;
+}
+
+function printErrorWithContext(e: any, ast: any, options: IOptions): void {
+  console.error(`${(options.filename || '')} ${e.message}`);
+  const src = options.source || astToCode(ast.ast).code;
+  // console.log(src.substring(e.start, e.end));
+  const lines = src.split('\n');
+  const errorLine = lines[e.loc.start.line - 1];
+
+  console.error(`Line ${e.loc.start.line - 1}: ${lines[e.loc.start.line - 2]}`);
+  console.error(`Line ${e.loc.start.line}: ` + errorLine.substring(0, e.loc.start.column)
+    + chalk.red(errorLine.substring(e.loc.start.column, e.loc.end.column))
+    + errorLine.substring(e.loc.end.column));
+  console.error(`Line ${e.loc.start.line + 1}: ${lines[e.loc.start.line]}`);
+  console.error();
+}

src/typings.ts

@@ -1,7 +1,7 @@
 import * as ASTQ from 'astq';
 import * as dom from 'dts-dom';
 import pascalCase = require('pascal-case');
-import { InstanceOfResolver } from './index';
+import { InstanceOfResolver, IOptions } from './index';
 import * as types from './types';
 
 export interface AstQuery {
@@ -10,8 +10,7 @@ export interface AstQuery {
   querySubtree(subtree: any, query: string): any[];
 }
 
-export function createTypings(moduleName: string|null, programAst: any,
-    instanceOfResolver: InstanceOfResolver | undefined): string {
+export function createTypings(moduleName: string|null, programAst: any, options: IOptions): string {
   const astq = new ASTQ();
   const ast = {
     ast: programAst,
@@ -25,7 +24,7 @@ export function createTypings(moduleName: string|null, programAst: any,
   const reactComponentName = getReactComponentName(ast);
   const propTypesName = getPropTypesName(ast);
   const importedTypes = getInstanceOfPropTypes(ast, propTypesName);
-  const importStatements = getImportStatements(ast, importedTypes, instanceOfResolver);
+  const importStatements = getImportStatements(ast, importedTypes, options.instanceOfResolver);
   const componentNames = getUniqueNames([
     ...getComponentNamesByPropTypeAssignment(ast),
     ...getComponentNamesByStaticPropTypeAttribute(ast),
@@ -50,7 +49,7 @@ export function createTypings(moduleName: string|null, programAst: any,
     const propTypes = getPropTypesFromAssignment(ast, componentName) ||
       getPropTypesFromStaticAttribute(ast, componentName);
     if (exportType) {
-      createExportedTypes(m, ast, componentName, reactComponentName, propTypes, propTypesName, exportType);
+      createExportedTypes(m, ast, componentName, reactComponentName, propTypes, propTypesName, exportType, options);
     }
   });
 
@@ -65,13 +64,13 @@ export function createTypings(moduleName: string|null, programAst: any,
 
 function createExportedTypes(m: dom.ModuleDeclaration, ast: AstQuery, componentName: string,
     reactComponentName: string|undefined, propTypes: any, propTypesName: string|undefined,
-      exportType: dom.DeclarationFlags): void {
+      exportType: dom.DeclarationFlags, options: IOptions): void {
   const classComponent = isClassComponent(ast, componentName, reactComponentName);
 
   const interf = dom.create.interface(`${componentName}Props`);
   interf.flags = dom.DeclarationFlags.Export;
   if (propTypes) {
-    createPropTypeTypings(interf, ast, propTypes, propTypesName);
+    createPropTypeTypings(interf, ast, propTypes, propTypesName, options);
     extractComplexTypes(m, interf, componentName);
   }
 
@@ -93,12 +92,12 @@ function createExportedTypes(m: dom.ModuleDeclaration, ast: AstQuery, componentN
 }
 
 function createPropTypeTypings(interf: dom.InterfaceDeclaration, ast: AstQuery, propTypes: any,
-    propTypesName: string|undefined): void {
+    propTypesName: string|undefined, options: IOptions): void {
   const res = ast.querySubtree(propTypes, `
     / ObjectProperty
   `);
   res.forEach(propertyAst => {
-    const typeDecl = types.get(ast, propertyAst.value, propTypesName);
+    const typeDecl = types.get(ast, propertyAst.value, propTypesName, options);
     const property = dom.create.property(propertyAst.key.name || propertyAst.key.value, typeDecl.type,
       typeDecl.optional ? dom.DeclarationFlags.Optional : 0);
     if (propertyAst.leadingComments && propertyAst.leadingComments[0].type === 'CommentBlock') {

tests/error-reporting-test.ts

@@ -1,4 +1,5 @@
 import test from 'ava';
+import * as stripAnsi from 'strip-ansi';
 
 import * as react2dts from '../src/index';
 
@@ -29,8 +30,7 @@ test('In case of error during shape type inference the error information should
     }
   `);
   const args = t.context.args.reduce((akku: any[], args: any[]) => [...akku, ...args], []);
-  const idx = args.indexOf('Line 6:     someShape: React.PropTypes.shape(shape)');
-  t.is(idx, 1);
+  t.is(stripAnsi(args[2]), 'Line 6:         someShape: React.PropTypes.shape(shape)');
 });
 
 test('In case of error during enum type inference the error information should be retained', t => {
@@ -44,8 +44,7 @@ test('In case of error during enum type inference the error information should b
     }
   `);
   const args = t.context.args.reduce((akku: any[], args: any[]) => [...akku, ...args], []);
-  const idx = args.indexOf('Line 6:     list: React.PropTypes.oneOf(list)');
-  t.is(idx, 1);
+  t.is(stripAnsi(args[2]), 'Line 6:         list: React.PropTypes.oneOf(list)');
 });
 
 test('In case of error during enum value creation inference the error information should be retained', t => {
@@ -59,8 +58,7 @@ test('In case of error during enum value creation inference the error informatio
     }
   `);
   const args = t.context.args.reduce((akku: any[], args: any[]) => [...akku, ...args], []);
-  const idx = args.indexOf('Line 6:     list: React.PropTypes.oneOf(Object.keys(object))');
-  t.is(idx, 1);
+  t.is(stripAnsi(args[2]), 'Line 6:         list: React.PropTypes.oneOf(Object.keys(object))');
 });
 
 test('In case of error during shape type inference the error information should be retained', t => {
@@ -74,6 +72,5 @@ test('In case of error during shape type inference the error information should
     }
   `);
   const args = t.context.args.reduce((akku: any[], args: any[]) => [...akku, ...args], []);
-  const idx = args.indexOf('Line 6:     shape: React.PropTypes.shape(some.shape)');
-  t.is(idx, 1);
+  t.is(stripAnsi(args[2]), 'Line 6:         shape: React.PropTypes.shape(some.shape)');
 });

typings/strip-ansi.d.ts

@@ -0,0 +1 @@
+declare module 'strip-ansi';