How to Customize the Comment Analysis

To customize the code entities (e.g., methods or field declarations) for which Teamscale expects a comment, Teamscale provides so-called selection predicates to specify code entities. This can be used to customize and fine-tune the comment analysis to your needs.

Supported Languages

The following languages support this feature:

• Java
• JavaScript
• C
• C#
• C++
• MATLAB
• Python
• Kotlin

Code Entity Selection Predicates

An entity selection predicate consists of primitives that can be connected using negation !, conjunction &, disjunction |, and parentheses ( and ). The primitives are listed in the following configuration boxes. Obviously, not all predicates are applicable to all programming languages.

Simple Example

An example that selects all public simple getters and setters would be

public & (simpleGetter | simpleSetter)

Language-level examples

A good starting point are the following examples

Java	public & (type | method | attribute) & !(simpleGetter | simpleSetter | annotated(Override) | override)
C#	public & (type | method | property) & !(simpleGetter | simpleSetter | annotated(Override) | override)
C++ (Comments expected in Headers)	type | (public & (attribute | (method & declaration)))
C++ (Comments expected at Implementation)	type | (public & (attribute | (method & !declaration)))

Predicate Reference

The following boxes provide an overview of the available predicates.

Predicate	Meaning
language(name)	Entities in files with the given language. If the given language name is invalid, no entities are matched. Valid names are for example JAVA and CPP.
module	Namespaces and modules.
type	Types, such as classes or structs.
method	Methods and functions.
declaration	Declarations of types and methods.
internal	Internal entities (C# keyword).
attribute	Attributes, fields and global variables.
property	All properties: defined attributes that have only method children.
statement	All statements.
meta	All meta information (defines, annotations, etc.).
public	All public entities, as well as methods inside interfaces, which are considered public in most languages.
protected	All protected entities.
override	All entities marked with override keyword.
private	All private entities.
default	All entities with default visibility.
final	All final entities.
static	All static entities.
primitive	All primitive entities (i.e. those without children).
subtype(name)	Entities by their subtype. The name parameter can e.g., be if to target if-statements. Other examples for the name parameter are constructor, destructor or while.
typeSubtype(name)	Entities by their parent type's subtype (e.g., to select all members of interfaces).
name(name)	Entities by their name. For example a method name.
nameRegex(regex)	Entities by their name using regular expression.
fileRegex(regex)	Entities by their containing file's unified path using regular expression, e.g. fileRegex(.*\.ts) matches all files with the extension ».ts«.
annotated(name)	All entities that are annotated with an annotation of given name (excluding the »@« sign).
simpleGetter	Simple getters, i.e. methods starting with »get« or »is« and containing at most one statement. Use simpleGetterCaseInsensitive for a case insensitive version.
simpleSetter	Simple setters, i.e. methods starting with »set« and containing at most one statement. Use simpleSetterCaseInsensitive for a case insensitive version.
simpleMethod(prefix)	Simple methods whose name starts with the given prefix. A method is simple, if it contains as most one statement. Use simpleMethodCaseInsensitive(prefix) for a case insensitive version.
export	All entities with ES6's export visibility.
typeexported	All entities (e.g. methods, attributes) within types that have ES6's export visibility.
extendsType	Classes that extend a specific type directly (e.g. extendsType(MyBaseClass))
isAbstract	All abstract entities.