public sealed interface KaType : KaLifetimeOwner, KaAnnotated {
    public val nullability: KaTypeNullability

    /**
     * The abbreviated type for this expanded [KaType], or `null` if this type has not been expanded from an abbreviated type or the
     * abbreviated type cannot be resolved.
     *
     * An abbreviated type is a type alias application that has been expanded to some other Kotlin type. For example, if we have a type

 * which can still be expanded.
 */
public enum class KaExpandedTypeRenderingMode {
    /**
     * Renders only the abbreviated type as-is, e.g. `foo.bar.StringAlias`.
     */
    RENDER_ABBREVIATED_TYPE,

    /**

public val KtType.classSymbol: KaClassLikeSymbol?
    get() = symbol

/**
 * Returns the [KaType]'s [abbreviated type][KaType.abbreviatedType], or the type itself if it doesn't have an abbreviated type.
 *
 * A common pattern is to prefer the abbreviated type if it exists, and otherwise take the original type, for example to find the best
 * target for navigation.
 */

                doLast { }
            }
        """

        when:
        run("sanityCheck", "--info")

        then:
        outputContains("Task name matched 'sanityCheck'")
        outputDoesNotContain("abbreviated")
        result.assertTaskExecuted(":sanityCheck")
        result.assertTaskNotExecuted(":safetyCheck")
    }

    def "logs info message for pattern match"() {
        setup:
        buildFile << """

	WorkloadAuthorizationType  = model.WorkloadAuthorizationType

	// nolint
	HttpProtocolOptionsType = "envoy.extensions.upstreams.http.v3.HttpProtocolOptions"
)

// GetShortType returns an abbreviated form of a type, useful for logging or human friendly messages
func GetShortType(typeURL string) string {
	return model.GetShortType(typeURL)
}

// GetMetricType returns the form of a type reported for metrics

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

var _ = (*interface /* ERROR "interface contains type constraints" */ {int})(nil)

// abbreviated test case from issue

type TypeSet interface{ int | string }

func _() {
	f((*TypeSet /* ERROR "interface contains type constraints" */)(nil))
}

	WorkloadType              = APITypePrefix + "istio.workload.Workload"
	WorkloadAuthorizationType = APITypePrefix + "istio.security.Authorization"
)

// GetShortType returns an abbreviated form of a type, useful for logging or human friendly messages
func GetShortType(typeURL string) string {
	switch typeURL {
	case ClusterType:
		return "CDS"
	case ListenerType:
		return "LDS"
	case RouteType:

 */
internal fun KaSymbolByFirBuilder.buildAbbreviatedType(coneType: ConeClassLikeType): KaUsualClassType? {
    return coneType.abbreviatedType?.let { abbreviatedConeType ->
        // If the resulting type is an error type, the abbreviated type couldn't be resolved. As per the contract of
        // `KaType.abbreviatedType`, we should return `null` in such cases. The user can then fall back to the expanded type.

        when:
        run("$projectPath:help", "--info")

        then:
        outputContains("Task path '$projectPath:help' matched project '$resolvedProject'")
        outputDoesNotContain("abbreviated")

        where:
        desc                                    | projectPath                           | resolvedProject

 * the expansion-site module instead of the use-site module in these tests, as we want to check the `KaType` when it's built with an
 * expanded type from a library vs. from a source module. (Abbreviated types from libraries and from sources aren't necessarily constructed
 * in the same way.)
 *
 * This test is different from [AbstractTypeByDeclarationReturnTypeTest] because we want to generate tests for extension-site modules with