This issue can be mitigated by removing the position information of the annotation desugered functions from the line number table. This will ignore the lines related to annotations from the code coverage. If we do so, annotation related (annotation desugared functions) lines will be excluded from the stack traces as well.
eg.,

1   annotation ZeroDiffAnnot zeroDivAnnot on function;
2
3   function zeroDiv(int n) returns boolean {
4     return n / 0 == 0;
5   }
6
7   @zeroDivAnnot {
8      value: "ZeroDiv",
9      out: zeroDiv(10)
10   }
11   function foo(int n) returns int {
12      return n;
13   }

error: {ballerina}DivisionByZero {"message":" / by zero"}
        at gabilan.test_project.0:zeroDiv(main.bal:4)
           gabilan.test__project.0:$annot_func$_0(main.bal:9)

If we remove the line numbers of annotation desugared functions from the line number table, the stack trace will not contain the line gabilan.test_project.0:$annot_func$_0(main.bal:9).
Since, the annotation related bytecode instructions are used during the test running, the jacoco will detect the lines related to those bytecode instructions as partially/fully covered.

It seems without removing the positions related to the annotations from the line number table, we can't avoid the annotations from the code coverage. Anyway the code coverage of actual code lines which are need to be covered by the user's test cases are depend on the availability of the tests.
So, IMO it's okay to show the annotation related lines as covered in the coverage report. @warunalakshitha @MaryamZi WDYT?

How do we decide if it is covered? For example, with the original example, a Review object is not even created, but relevant code lines are shown as covered, which is not correct IMO.

How do we decide if it is covered? For example, with the original example, a Review object is not even created, but relevant code lines are shown as covered, which is not correct IMO.

Agree. But the following case also panics without the function foo() is being called inside the main.

1   annotation ZeroDiffAnnot zeroDivAnnot on function;
2
3   function zeroDiv(int n) returns boolean {
4     return n / 0 == 0;
5   }
6
7   @zeroDivAnnot {
8      value: "ZeroDiv",
9      out: zeroDiv(10)
10   }
11   function foo(int n) returns int {
12      return n;
13   }

This is happening due to the annotation desugared are getting called during the initialization phase.

It may not necessary to consider annotations for code coverage, since they usually provide structured metadata about a particular construct. So we can omit annotation related lines from code coverage.
But what about removing the entry related to the line-number 9 of the above example from the stack trace?

Spec says, An annotation applied to a module-level declaration is evaluated when the module is initialized. An annotation applied to a service constructor is evaluated when the service constructor is evaluated. An annotation occurring within a type descriptor is evaluated when the type descriptor is resolved.

Since the annotations related lines of module-level declarations are evaluated at module initialization, the bytecode instructions related those lines are executed during the test run, even there are no added tests. So jacoco marks those annotation related lines are covered.

There are lines showed as covered in the following case without having relevant added tests.

This is because these functions are called at module init, start and stop.