feature: @putout/printer: type-checker: types

Author: coderaiser

lib/tokenize/type-checker/instrument.d.ts

@@ -0,0 +1,21 @@
+type TypeChecker = (path: unknown, options?: Record<string, unknown>) => boolean;
+
+type CoverageEntry = {
+    covered: Set<number>;
+    typeNames: unknown[];
+};
+
+type InstrumentOverride = {
+    env?: {TYPE_CHECK?: string; [key: string]: unknown};
+    coverage?: Map<string, CoverageEntry>;
+    instrumentName?: string;
+    [key: string]: unknown;
+};
+
+export function instrument(
+    typeNames: unknown[],
+    fn: TypeChecker,
+    overrides?: InstrumentOverride,
+): TypeChecker;
+
+export function getCoverage(): Map<string, CoverageEntry>;

lib/tokenize/type-checker/report.d.ts

@@ -0,0 +1,6 @@
+type CoverageEntry = {
+    covered: Set<number>;
+    typeNames: unknown[];
+};
+
+export function report(coverage: Map<string, CoverageEntry>): [number, string];

lib/tokenize/type-checker/type-checker.d.ts

@@ -0,0 +1,16 @@
+type TypeChecker = (path: unknown, options?: Record<string, unknown>) => boolean;
+
+type TypeCheckerOverride = {
+    instrumentCoverage?: (
+        typeNames: unknown[],
+        fn: TypeChecker,
+        overrides?: Record<string, unknown>,
+    ) => TypeChecker;
+    instrumentName?: string;
+    [key: string]: unknown;
+};
+
+export function createTypeChecker(
+    typeNames: unknown[],
+    overrides?: TypeCheckerOverride,
+): TypeChecker;

lib/tokenize/type-checker/when-tests-ends.d.ts

@@ -0,0 +1,8 @@
+type WhenTestsEndsOverride = {
+    log?: (message: string) => void;
+    getCoverage?: () => Map<string, {covered: Set<number>; typeNames: unknown[]}>;
+    report?: (coverage: Map<string, {covered: Set<number>; typeNames: unknown[]}>) => [number, string];
+    [key: string]: unknown;
+};
+
+export function whenTestsEnds(overrides?: WhenTestsEndsOverride): number;

test/printer.errors.ts

@@ -5,24 +5,25 @@ import {
     visitors,
     Format,
     Semantics,
-    Options,
-    Visitors,
     Visitor,
     Printer,
 } from '#printer';
 
 const {identifier} = types;
+const id = (a: unknown) => a;
 
 // THROWS Expected 4 arguments, but got 1.
 maybeVisitor(1);
 
 // THROWS Argument of type 'number' is not assignable to parameter of type 'Visitor'
 maybeVisitor(1, 2, 3, 4);
+
 // THROWS Argument of type 'number' is not assignable to parameter of type 'Node'
 const a = maybeVisitor(visitors.ArrayExpression, 2, 3, 4);
 
 // THROWS Type 'void' is not assignable to type 'string'
 const b: string = a;
+id(b);
 
 // THROWS Argument of type 'number' is not assignable to parameter of type 'Node'
 print(1);
@@ -37,16 +38,17 @@ print(identifier('hello'), {
 
 // THROWS Type '{}' is missing the following properties from type 'Format': indent, newline, space, splitter, quote
 const format: Format = {};
+id(format);
 
 // THROWS Type '{}' is missing the following properties from type 'Semantics': roundBraces, comments, maxPropertiesInOneLine, maxSpecifiersInOneLine, and 3 more.
 const semantics: Semantics = {};
-
-const opts: Options = {};
+id(semantics);
 
 // THROWS Type '{}' is not assignable to type 'Visitor'
 const visitor: Visitor = {};
+id(visitor);
 
-// THROWS Type '{}' is missing the following properties from type 'Printer': print, maybe, indent, traverse
-const printer: Printer = {};
-
-const vt: Visitors = {};
+const fn = (printer: Printer) => printer;
+const printer = {};
+// THROWS Argument of type '{}' is not assignable to parameter of type 'Printer'.
+fn(printer);

test/type-checker.errors.ts

@@ -0,0 +1,19 @@
+import {createTypeChecker} from '#type-checker';
+
+// THROWS Expected 1-2 arguments, but got 3.
+createTypeChecker([], {}, {});
+
+// THROWS Expected 1-2 arguments, but got 0.
+createTypeChecker();
+
+// THROWS Argument of type 'number' is not assignable to parameter of type 'unknown[]'.
+createTypeChecker(1);
+
+const isBlockLike = createTypeChecker(['Program', 'BlockStatement']);
+
+// THROWS Argument of type 'boolean' is not assignable to parameter of type 'Record<string, unknown>'
+isBlockLike({type: 'Program'}, true);
+
+// THROWS Argument of type 'number' is not assignable to parameter of type 'Record<string, unknown>'
+isBlockLike({type: 'Program'}, 1);
+

test/type-checker.types.ts

@@ -0,0 +1,67 @@
+import {createTypeChecker} from '#type-checker';
+import {instrument, getCoverage} from '#type-checker/instrument';
+import {report} from '#type-checker/report';
+import {whenTestsEnds} from '#type-checker/when-tests-ends';
+
+// Simple string type names
+createTypeChecker(['Program', 'BlockStatement'])({type: 'Program'});
+
+// Predicate function
+const isEmptyBody = (_a: {node: {body: {body: unknown[]}}}) => !_a.node.body.body.length;
+createTypeChecker([isEmptyBody])({node: {body: {body: []}}});
+
+// Tuple with string
+createTypeChecker([
+    ['-', 'BlockStatement'],
+])({type: 'Program'});
+
+// DSL string
+createTypeChecker([
+    '+: parentPath -> ExportDefaultDeclaration',
+])({
+    parentPath: {type: 'ExportDefaultDeclaration'},
+});
+
+// DSL string with negation
+createTypeChecker([
+    '+: parentPath -> !CallExpression',
+])({});
+
+// Tuple with DSL and function
+const hasFnBody = (_a: {node: {body: {body: unknown[]}}}) => _a.node.body.body.length;
+createTypeChecker([
+    ['-: parentPath -> !', 'ExportDefaultDeclaration'],
+    ['+', hasFnBody],
+])({
+    parentPath: {type: 'ExportDefaultDeclaration'},
+    type: 'BlockStatement',
+    node: {body: {body: []}},
+});
+
+// Override with instrumentCoverage and instrumentName
+createTypeChecker([
+    '+: -> BlockStatement',
+], {
+    instrumentName: 'hello',
+});
+
+// Call with options
+const hasFnBodyOptions = (_a: unknown, b: Record<string, unknown>) => b.is;
+createTypeChecker([
+    ['+', hasFnBodyOptions],
+])({
+    type: 'FunctionDeclaration',
+}, {
+    is: true,
+});
+
+// instrument function
+instrument(['+: -> StringLiteral'], (_a: unknown) => true, {
+    instrumentName: 'TYPE_CHECK',
+})({});
+
+// getCoverage + report
+report(getCoverage());
+
+// whenTestsEnds
+whenTestsEnds();