fix: improve type coverage calculation

don't count function and class declearations when calculating the type coverage.
Also return the type coverage percentage

src/index.ts

@@ -2,3 +2,4 @@ export * from './apply-types';
 export * from './instrument';
 export * from './node-register';
 export * from './type-collector';
+export * from './type-coverage';

src/type-coverage.spec.ts

@@ -22,7 +22,56 @@ describe('type-coverage', () => {
         });
         expect(typeCoverage(program)).toEqual({
             knownTypes: 1,
+            percentage: 50,
             totalTypes: 2,
         });
     });
+
+    it('should not count function declarations when calculating the type coverage', () => {
+        const input = `
+            function f() {}
+        `;
+
+        const program = getProgram({
+            tsCompilerHost: virtualCompilerHost(input, 'c:/test.ts'),
+            tsConfig: 'tsconfig.json',
+            tsConfigHost: virtualTsConfigHost({
+                compilerOptions: {
+                    noImplicitThis: true,
+                    target: 'es2015',
+                },
+                include: ['test.ts'],
+            }),
+        });
+        expect(typeCoverage(program)).toEqual({
+            knownTypes: 0,
+            percentage: 100,
+            totalTypes: 0,
+        });
+    });
+
+    it('should not count class declarations when calculating the type coverage', () => {
+        const input = `
+            class MyClass {
+                constructor () {}
+            }
+        `;
+
+        const program = getProgram({
+            tsCompilerHost: virtualCompilerHost(input, 'c:/test.ts'),
+            tsConfig: 'tsconfig.json',
+            tsConfigHost: virtualTsConfigHost({
+                compilerOptions: {
+                    noImplicitThis: true,
+                    target: 'es2015',
+                },
+                include: ['test.ts'],
+            }),
+        });
+        expect(typeCoverage(program)).toEqual({
+            knownTypes: 0,
+            percentage: 100,
+            totalTypes: 0,
+        });
+    });
 });

src/type-coverage.ts

@@ -5,11 +5,15 @@ export function typeCoverage(program: ts.Program) {
 
     const result = {
         knownTypes: 0,
+        percentage: 100,
         totalTypes: 0,
     };
 
     function visit(node: ts.Node) {
-        if (ts.isIdentifier(node)) {
+        if (
+            ts.isIdentifier(node) &&
+            (!node.parent || (!ts.isFunctionDeclaration(node.parent) && !ts.isClassDeclaration(node.parent)))
+        ) {
             const type = checker.getTypeAtLocation(node);
             if (type) {
                 result.totalTypes++;
@@ -27,5 +31,9 @@ export function typeCoverage(program: ts.Program) {
         }
     }
 
+    if (result.totalTypes > 0) {
+        result.percentage = 100 * result.knownTypes / result.totalTypes;
+    }
+
     return result;
 }