@Test
    fun `type-checks assignment of subtype to superclass type`() {
        val result = schema.resolve(
            """
            superClassProp = sub()
            """.trimIndent()
        )

        assertEquals(1, result.assignments.size)
    }

    @Test
    fun `type-checks assignment of subtype to super interface type`() {
        val result = schema.resolve(
            """

        get() = analysisSession.token

    private val typeMapper by lazy { KaFe10JvmTypeMapperContext(analysisContext.resolveSession) }

    override fun mapTypeToJvmType(type: KaType, mode: TypeMappingMode): Type {
        val kotlinType = (type as KaFe10Type).fe10Type
        return typeMapper.mapType(kotlinType, mode)
    }

    override fun isPrimitiveBacked(type: KaType): Boolean {
        val kotlinType = (type as KaFe10Type).fe10Type

        writeEnum(value.type)
        writeInt(value.ordinalGroup.ordinal)
    }

    override suspend fun ReadContext.decode(): OrdinalNode {
        val ordinalType = readEnum<OrdinalNode.Type>()
        val ordinal = readInt()
        return ordinalGroups.group(ordinal).locationsNode(ordinalType)
    }

            val symbol = declaration.getSymbol() as KaCallableSymbol
            val type = symbol.returnType
            val substituted = substitutor.substitute(type)
            val substitutedOrNull = substitutor.substituteOrNull(type)

            prettyPrint {
                appendLine("PSI type: ${declaration.typeReference?.text}")

        val ktCallExpression = ktFile.findDescendantOfType<KtCallExpression>()!!
        ktCallExpression.assertIsCallOf(CallableId(StandardNames.COLLECTIONS_PACKAGE_FQ_NAME, Name.identifier("listOf")))

        // builtin type
        val typeReference = ktFile.findDescendantOfType<KtNamedFunction>()!!.typeReference!!
        typeReference.assertIsReferenceTo(StandardClassIds.Float)
    }

        this.name = "$description${if (performanceTestBuildSpec.withoutDependencies) " (without dependencies)" else ""}"
        val type = performanceTestBuildSpec.type
        val os = performanceTestBuildSpec.os
        val arch = performanceTestBuildSpec.arch
        val buildTypeThis = this

                }
            }
            types.forEach(::visit)
        }

        return PreIndex().apply {
            allTypesToVisit.forEach { type ->
                addType(type)
                val properties = propertyExtractor.extractProperties(type)
                properties.forEach {
                    it.claimedFunctions.forEach { claimFunction(type, it) }
                    addProperty(

  auto encoding = mlir::dyn_cast_or_null<mlir::mhlo::TypeExtensionsAttr>(
      type.getEncoding());
  return (encoding && !encoding.getBounds().empty());
}

bool HasStaticShapeOrBounded(Value val) {
  auto type = val.getType();
  if (mlir::isa<UnrankedTensorType>(type)) {
    return false;
  }
  if (mlir::isa<RankedTensorType>(type)) {
    auto ranked_tensor = mlir::dyn_cast<RankedTensorType>(type);

    fun bind(type: Class<*>, codec: Codec<*>) {
        require(bindings.all { it.encodingForType(type) == null }) {
            "There's already an encoding for type '$type'"
        }
        val codecForAny = codec.uncheckedCast<Codec<Any>>()
        val encodingProducer = producerForSubtypesOf(type, codecForAny)
        bind(encodingProducer, codecForAny)
    }

	"unicode"
)

// conversion type-checks the conversion T(x).
// The result is in x.
func (check *Checker) conversion(x *operand, T Type) {
	constArg := x.mode == constant_

	constConvertibleTo := func(T Type, val *constant.Value) bool {
		switch t, _ := under(T).(*Basic); {
		case t == nil:
			// nothing to do
		case representableConst(x.val, check, t, val):
			return true
		case isInteger(x.typ) && isString(t):