is KaSamConstructorSymbol -> callableId ?: name
                    is KaConstructorSymbol -> "<constructor>"
                    is KaPropertyGetterSymbol -> callableId ?: "<getter>"
                    is KaPropertySetterSymbol -> callableId ?: "<setter>"
                    is KaAnonymousFunctionSymbol -> "<anonymous function>"
                    else -> error("unexpected symbol kind in KaCall: ${this@with::class}")
                }

        val testSourceFileTree: String
        when {
            descriptor.language === Language.CPP -> {
                exampleClass = if (descriptor.componentType === ComponentType.LIBRARY) "Hello" else "Greeter"
                sourceFile = (if (descriptor.componentType === ComponentType.LIBRARY) "hello" else "app") + ".cpp"

            )
        }
    }

    /**
     * This class recursively visits all calls of functions and getters, and if the function or the getter used for a call has
     * an annotation whose FqName is [annotationFqName], it runs [handleFunctionWithAnnotation] for the function or the getter.
     */
    private class CheckCallsWithAnnotationVisitor(
        private val annotationFqName: String,

 */
```

HTML tags for other block-level elements, such as `<ul>` or `<table>`, are not preceded with `<p>`.

### 1.1.4 Symbols

Entities for the less than symbol (<) and the greater than symbol (>) should be written as `&lt`; and `&gt;`. 
Similarly, the ampersand (&) should be written as `&amp;`:

```java
/**
 * This &amp; that.
 */
```

### 1.1.5 Links

  repositories are "really" offline, since offline mode is more of a behavior,
  and this will lead to counter-intuitive results. A different feature may exist
  unimplemented, which is to detect when the network is down and provide better
  feedback for that case. However, when offline mode is declared, nothing
  earmarked as remote should be accessed, regardless of whether it is actually
  a physically local resource.

        /**
         * Not all expressions appear in the [ControlFlowGraph].
         * Still, if we find at least some of them, it's very unlikely that we will ever find a better graph.
         */
        val firCandidates = buildSet {
            fun addCandidate(firCandidate: FirElement) {
                add(firCandidate)

                if (firCandidate is FirBlock) {

    session.jvmTypeMapper.mapType(this, mode, signatureWriter) {
        val containingFile = useSitePosition.containingKtFile
        // parameters for default setters does not have kotlin origin, but setter has
            ?: (useSitePosition as? KtLightParameter)?.parent?.parent?.containingKtFile
            ?: return@mapType null
        val correspondingImport = containingFile.findImportByAlias(it) ?: return@mapType null

         * (via generateReflectiveAccessForGetter) and it is called for the private access member lowered to the getter/setter call.
         * If a private property has no getter/setter (the typical situation for simple private properties without explicitly defined
         * getter/setter) then this method is not used at all. Instead

                getObjectByResolvedOrigin(addedObject.objectOrigin)
                apply(addedObject, conversionFilter)
                // TODO: maybe add the "containers" to the schema, so that added objects can be better expressed in this interpretation step
            }

            objectReflection.customAccessorObjects.forEach { customAccessor ->

            // is different from the return type of the constructor.
            //
            // TODO: This seems a little indirect. Is there a better way to do this? For FE1.0 there is
            // a special `TypeAliasConstructorDescriptor` for this case. For FIR there is
            // FirConstructor.originalConstructorIfTypeAlias but that doesn't seem to help here as it