misc edits

README.md

@@ -31,6 +31,11 @@ An `$ExpectType` directive tests the type of the expression on the next line. Th
     npm install -g typings-checker
     typings-checker your-test.ts
 
+## options
+
+* `--noLines` (`-l`): hide line numbers in output -- useful if you don't want these clogging diff logs when you add or remove a line.
+* `--verbose` (`-v`): shows code samples around your errors. could be used as an alternative to the above.
+
 ## Development
 
 ```

package.json

@@ -4,6 +4,7 @@
   "description": "Positive and negative assertions about TypeScript types and errors",
   "main": "src/index.js",
   "scripts": {
+    "prepublish": "tsc ./src/index.ts",
     "test": "./update-tests.sh"
   },
   "bin": {
@@ -21,12 +22,17 @@
     "@types/lodash": "^4.14.47",
     "@types/mocha": "^2.2.36",
     "@types/node": "^7.0.0",
+    "@types/yargs": "^6.5.0",
     "chai": "^3.5.0",
     "mocha": "^3.2.0",
-    "ts-node": "^2.0.0"
+    "ts-node": "^2.0.0",
+    "typescript": "^2.1.4"
   },
   "dependencies": {
     "lodash": "^4.17.4",
-    "typescript": "^2.1.4"
+    "yargs": "^6.6.0"
+  },
+  "peerDependencies": {
+    "typescript": "2.x"
   }
 }

src/checker.ts

@@ -1,59 +1,6 @@
 import * as ts from 'typescript';
 import * as _ from 'lodash';
-
-interface TypeAssertion {
-  kind: 'type';
-  type: string;
-  line: number;  // line that the assertion applies to; 0-based.
-}
-
-interface ErrorAssertion {
-  kind: 'error';
-  pattern: string;
-  line: number;  // line that the assertion applies to; 0-based.
-}
-
-type Assertion = TypeAssertion | ErrorAssertion;
-
-export interface NodedAssertion {
-  assertion: Assertion;
-  node: ts.Node;
-  type: ts.Type;
-  error?: ts.Diagnostic;
-}
-
-interface LineNumber {
-  line: number;  // 0-based
-}
-
-export interface WrongTypeFailure extends LineNumber {
-  type: 'WRONG_TYPE';
-  expectedType: string;
-  actualType: string;
-}
-
-export interface UnexpectedErrorFailure extends LineNumber {
-  type: 'UNEXPECTED_ERROR';
-  message: string;
-}
-
-export interface WrongErrorFailure extends LineNumber {
-  type: 'WRONG_ERROR';
-  expectedMessage: string;
-  actualMessage: string;
-}
-
-export interface MissingErrorFailure extends LineNumber {
-  type: 'MISSING_ERROR';
-  message: string;
-}
-
-type Failure = WrongTypeFailure | UnexpectedErrorFailure | WrongErrorFailure | MissingErrorFailure;
-
-export interface Report {
-  numSuccesses: number;
-  failures: Failure[];
-}
+import { Assertion, TypeAssertion, ErrorAssertion, Failure, WrongTypeFailure, UnexpectedErrorFailure, WrongErrorFailure, MissingErrorFailure, NodedAssertion, Report } from './types';
 
 // Extract information about the type/error assertions in a source file.
 // The scanner should be positioned at the start of the file.
@@ -102,6 +49,7 @@ export function attachNodesToAssertions(
       const pos = node.getStart();
       const { line } = source.getLineAndCharacterOfPosition(pos);
       const assertionIndex = _.findIndex(assertions, {line});
+      // console.warn(`checked for assertions at line ${line}: ${assertionIndex}`);
       if (assertionIndex >= 0) {
         const assertion = assertions[assertionIndex];
         const type = checker.getTypeAtLocation(node.getChildren()[0]);
@@ -116,7 +64,15 @@ export function attachNodesToAssertions(
 
   collectNodes(source);
   if (assertions.length) {
-    console.error(assertions);
+    let prettyAssertions = assertions.map(o => {
+      const errorMap: { [k: string]: string } = {
+        type: `$ExpectType ${(<TypeAssertion>o).type}`,
+        error: `$ExpectError ${(<ErrorAssertion>o).pattern}`,
+      };
+      let msg: string = <string> errorMap[o.kind];
+      return `${o.line+1}: ${msg}`;
+    });
+    console.error(JSON.stringify(prettyAssertions, null, '\t'));
     throw new Error('Unable to attach nodes to all assertions.');
   }
 
@@ -127,13 +83,14 @@ export function generateReport(
   checker: ts.TypeChecker,
   nodedAssertions: NodedAssertion[],
   diagnostics: ts.Diagnostic[],
+  source: ts.SourceFile,
 ): Report {
   const failures = [] as Failure[];
   let numSuccesses = 0;
 
   // Attach errors to nodes; if this isn't possible, then the error was unexpected.
   for (const diagnostic of diagnostics) {
-    let { line } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+    let line = diagnostic.file && diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start).line;
 
     const nodedAssertion = _.find(nodedAssertions, {assertion: {line}});
     if (nodedAssertion) {
@@ -149,13 +106,18 @@ export function generateReport(
   }
 
   // Go through and check all the assertions.
-  for (const {assertion, type, error} of nodedAssertions) {
+  for (const noded of nodedAssertions) {
+    let { assertion, type, error, node } = noded;
+    let { pos, end } = node;
+    let code = source.text.substring(pos, end);
     const line = assertion.line;
+    // let base = { code, line };
     if (assertion.kind === 'error') {
       if (!error) {
         failures.push({
           type: 'MISSING_ERROR',
           line,
+          code,
           message: assertion.pattern
         });
       } else {
@@ -164,6 +126,7 @@ export function generateReport(
           failures.push({
             type: 'WRONG_ERROR',
             line,
+            code,
             expectedMessage: assertion.pattern,
             actualMessage: message,
           });
@@ -177,6 +140,7 @@ export function generateReport(
         failures.push({
           type: 'WRONG_TYPE',
           line,
+          code,
           expectedType: assertion.type,
           actualType,
         })
@@ -204,5 +168,5 @@ export default function checkFile(
 ): Report {
   const assertions = extractAssertions(scanner, source);
   const nodedAssertions = attachNodesToAssertions(source, checker, assertions);
-  return generateReport(checker, nodedAssertions, diagnostics);
+  return generateReport(checker, nodedAssertions, diagnostics, source);
 }

src/index.ts

@@ -10,18 +10,37 @@
  */
 
 import * as ts from 'typescript';
+let argv = require('yargs')
+  .usage('Usage: <file> [options]')
+
+  .alias('l', 'noLines')
+  .describe('l', 'skip line numbers in output to keep it more diff-friendly')
+
+  .alias('v', 'verbose')
+  .describe('v', 'also print relevant code')
+
+  .argv;
 
 import checkFile from './checker';
 
-const [,, tsFile] = process.argv;
+const [tsFile] = argv._;
+const { noLines, verbose } = argv;
 
-// TODO: read options from a tsconfig.json file.
-const options: ts.CompilerOptions = {};
-const host = ts.createCompilerHost(options, true);
+// read options from a tsconfig.json file.
+let host = ts.createCompilerHost({}, true);
+const options: ts.CompilerOptions = ts.readConfigFile('tsconfig.json', (path: string) => host.readFile(path)).config['compilerOptions'];
+// console.log(options);
+if (options) {
+  host = ts.createCompilerHost(options, true);
+}
 
 const program = ts.createProgram([tsFile], options, host);
 
 const source = program.getSourceFile(tsFile);
+if (!source) {
+  console.error(`could not load content of ${tsFile}`);
+  process.exit(1);
+}
 const scanner = ts.createScanner(
     ts.ScriptTarget.ES5, false, ts.LanguageVariant.Standard, source.getFullText());
 
@@ -31,7 +50,7 @@ const diagnostics = ts.getPreEmitDiagnostics(program);
 const report = checkFile(source, scanner, checker, diagnostics);
 
 for (const failure of report.failures) {
-  const { line } = failure;
+  const { line, code } = failure;
   let message: string;
   switch (failure.type) {
     case 'UNEXPECTED_ERROR':
@@ -47,7 +66,7 @@ for (const failure of report.failures) {
       message = `Expected type\n  ${failure.expectedType}\nbut got:\n  ${failure.actualType}`;
       break;
   }
-  console.error(`${tsFile}:${line + 1}: ${message}\n`);
+  console.error(`${tsFile}:${noLines ? '' : ((line + 1) + ':')}${verbose && code ? code + '\n\n' : ' '}${message}\n`);
 }
 
 const numFailures = report.failures.length;

src/types.ts

@@ -0,0 +1,62 @@
+import * as ts from 'typescript';
+
+export interface LineNumber {
+  line: number;  // 0-based
+}
+
+export interface IAssertion extends LineNumber {
+  kind: string;
+}
+
+export interface TypeAssertion extends IAssertion {
+  kind: 'type';
+  type: string;
+}
+
+export interface ErrorAssertion extends IAssertion {
+  kind: 'error';
+  pattern: string;
+}
+
+export type Assertion = TypeAssertion | ErrorAssertion;
+
+export interface NodedAssertion {
+  assertion: Assertion;
+  node: ts.Node;
+  type: ts.Type;
+  error?: ts.Diagnostic;
+}
+
+export interface IFailure extends LineNumber {
+  code?: string;
+  type: string;
+}
+
+export interface WrongTypeFailure extends IFailure {
+  type: 'WRONG_TYPE';
+  expectedType: string;
+  actualType: string;
+}
+
+export interface UnexpectedErrorFailure extends IFailure {
+  type: 'UNEXPECTED_ERROR';
+  message: string;
+}
+
+export interface WrongErrorFailure extends IFailure {
+  type: 'WRONG_ERROR';
+  expectedMessage: string;
+  actualMessage: string;
+}
+
+export interface MissingErrorFailure extends IFailure {
+  type: 'MISSING_ERROR';
+  message: string;
+}
+
+export type Failure = WrongTypeFailure | UnexpectedErrorFailure | WrongErrorFailure | MissingErrorFailure;
+
+export interface Report {
+  numSuccesses: number;
+  failures: Failure[];
+}

tests/basics/type-assertion-failure.ts.out

@@ -1,4 +1,4 @@
-tests/basics/type-assertion-failure.ts:6: Expected type
+tests/basics/type-assertion-failure.ts:6:: Expected type
   string
 but got:
   number

tests/basics/unexpected-error.ts.out

@@ -1,4 +1,4 @@
-tests/basics/unexpected-error.ts:5: Unexpected error
+tests/basics/unexpected-error.ts:5:: Unexpected error
   Property 'c' does not exist on type '{ a: string; b: number; }'.
 
 tests/basics/unexpected-error.ts: 0 / 1 checks passed.

tests/underscore-any.ts.out

@@ -1,18 +1,24 @@
-tests/underscore-any.ts:7: Expected type
+tests/underscore-any.ts:7:: Expected type
   number
 but got:
   any
 
-tests/underscore-any.ts:9: Expected error Operator '==' cannot be applied to types 'number' and 'string'.
+tests/underscore-any.ts:9:: Expected error
+  Operator '==' cannot be applied to types 'number' and 'string'.
+but got:
+  Parameter 'x' implicitly has an 'any' type.
 
-tests/underscore-any.ts:11: Expected type
+tests/underscore-any.ts:11:: Expected type
   number
 but got:
   any
 
-tests/underscore-any.ts:13: Expected error Property 'y' does not exist on type '{ x: number; }'.
+tests/underscore-any.ts:13:: Expected error
+  Property 'y' does not exist on type '{ x: number; }'.
+but got:
+  Parameter 'v' implicitly has an 'any' type.
 
-tests/underscore-any.ts:15: Expected type
+tests/underscore-any.ts:15:: Expected type
   { x: number; }
 but got:
   any

update-tests.sh

@@ -5,6 +5,7 @@ set +o errexit
 
 for test in $(find tests -name '*.ts'); do
   node src/index.js $test > $test.out 2>&1
+  rc=${PIPESTATUS[0]}; if [[ $rc != 0 ]]; then exit $rc; fi
 done
 
 # This shows changes and sets the exit code.