Code coverage calculation: Skip type definitions (e.g. Interface).

[johannes-mathes]

Bug description

When I define an interface in assembly script and I test the class implementing the interface, sometimes the code is marked as "covered", but sometimes not.

Steps to reproduce

define an interface in assembly script, write an implementing class. write a unit test with the assemblyscript framework.

• Without the test code doing a cast, the interface will be marked as uncovered
• If there is only one implementing class (no poliymorphism) and a cast, the typical compiler setting will optimize it -> marked as uncovered
• If there are more implementing classes and a cast, it is marked as covered

Desired behavior

According to industry best practices, the unit test framework should do:

Executable Code -> consider:

• Class methods, Functions
• Control structures (e.g., if, for, while)
• Expressions and statements

Not included:

• Interfaces
• Type definitions (type, interface)
• Comments
• Declarations without logic (e.g., const, let without initialization)

[Changqing-JING]

pseudo code description

Interface C{
abstract foo();
}

class A extends C{
  override foo(){
    dosomething_A;
 }
}

class B extends C{
  override foo(){
    dosomething_B;
 }
}

let a = new A();
a.foo()
let b = new B();
b.foo();

Currently, the abstract C::foo will be marked as uncovered.

Reason:
Abstract function doesn't have implementation, but it has bytecode function body for virtual function dispatch. This function is generated by compiler automatically.
pseudo code

type = get_runtime_type();
impl = lookup(type);
impl();

This function can only be called when

let c = new A();
c.foo();

In bytecode point of view, the c.foo() marked uncovered in first example is correct. But it leads to strange user experience.

Possible solution:

1. Exclude abstract functions
2. Exclude compiler auto generated functions.