public object ALWAYS : KaCallableReturnTypeFilter {
        override fun shouldRenderReturnType(analysisSession: KaSession, type: KaType, symbol: KaCallableSymbol): Boolean {
            return true
        }

    }

    public object NO_UNIT_FOR_FUNCTIONS : KaCallableReturnTypeFilter {
        override fun shouldRenderReturnType(analysisSession: KaSession, type: KaType, symbol: KaCallableSymbol): Boolean {

KaDataFlowExitPointSnapshot:
  defaultExpressionInfo = null
  hasEscapingJumps = false
  hasJumps = true
  hasMultipleJumpKinds = true
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return,
    break
  ]
  returnValueType = null
  valuedReturnExpressions = []

            val scopeContextStringRepresentation = render(ktScopeContext, renderDefaultImportingScope)
            val scopeContextStringRepresentationPretty = render(ktScopeContext, renderDefaultImportingScope, printPretty = true)

            testServices.assertions.assertEqualsToTestDataFileSibling(scopeContextStringRepresentation)

                    KaClassKind.INTERFACE -> !superType.isAny
                    else -> true
                }
            }
        }
    }

    public object ALL : KaSuperTypesFilter {
        override fun filter(analysisSession: KaSession, superType: KaType, symbol: KaClassOrObjectSymbol): Boolean {
            return true
        }
    }

    public object NONE : KaSuperTypesFilter {

  defaultExpressionInfo = DefaultExpressionInfo:
    expression = numbers.forEach {
            if (it == 3) {
                return
            }
        }
    type = kotlin.Unit
  hasEscapingJumps = true
  hasJumps = true
  hasMultipleJumpKinds = false
  hasMultipleJumpTargets = false
  jumpExpressions = [
    return
  ]
  returnValueType = null
  valuedReturnExpressions = []

     * e.g., according to the annotation on the containing declarations.
     * - `true` means they should be suppressed.
     * - `false` means they should appear.
     * - `null` is no-op by default, i.e., their suppression/appearance is determined by type annotations.
     *
     * @param preserveAnnotations if **true** the result [PsiType] will have converted annotations from the original [type][this]
     */

 * rather than formatting first by calling <code>toString()</code>.
 *
 * @since 4.0.0
 */
@Experimental
@Provider
public interface Log {
    /**
     * {@return true if the <b>debug</b> error level is enabled}.
     */
    boolean isDebugEnabled();

    /**
     * Sends a message to the user in the <b>debug</b> error level.
     *
     * @param content the message to log

                val approximatedDirectSuperTypes = expectedType.getDirectSuperTypes(shouldApproximate = true)
                val allSuperTypes = expectedType.getAllSuperTypes()
                val approximatedAllSuperTypes = expectedType.getAllSuperTypes(shouldApproximate = true)

                buildString {
                    fun List<KaType>.print(name: String) {
                        appendLine(name)

     *    }
     * }
     * ```
     *
     * For the case provided, inside the call `A.foo()`,
     * the `A` is an implicit reference to the companion object, so `isImplicitReferenceToCompanion` returns `true`
     *
     * @return `true` if the reference is an implicit reference to a companion object, `false` otherwise.
     */
    public fun KtReference.isImplicitReferenceToCompanion(): Boolean = withValidityAssertion {

  public void testAllFilesPresentInSingleSymbolByPsi() {
    KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("analysis/analysis-api/testData/symbols/singleSymbolByPsi"), Pattern.compile("^(.+)\\.kts$"), null, true);
  }

  @Nested
  @TestMetadata("analysis/analysis-api/testData/symbols/singleSymbolByPsi/contracts")
  @TestDataPath("$PROJECT_ROOT")
  public class Contracts {
    @Test