#set ( $type = ${types.getOrDefault($field,${types.getOrDefault($field.type,$field.type)})} )
      #if ( $type.startsWith("List<") )
        #set ( $type = ${type.replace('List<','Collection<')} )
      #end
      #if ( $type == 'boolean' )
        Boolean ${field.name};
      #elseif ( $type == 'int' )
        Integer ${field.name};
      #else
        ${type} ${field.name};
    #end
    #end

    /**
     * Approximates [KaType] with a supertype which can be rendered in a source code
     *
     * Return `null` if the type do not need approximation and can be rendered as is
     * Otherwise, for type `T` return type `S` such `T <: S` and `T` and every type argument is denotable
     */
    public fun KaType.approximateToSuperPublicDenotable(approximateLocalTypes: Boolean): KaType? =

            else -> FunctionSemanticsInternal.DefaultPure(returnTypeClassifier.toDataTypeRefOrError())
        }
    }

    private
    fun KType.toKClass() = (classifier ?: error("unclassifiable type $this is used in the schema")) as? KClass<*>
        ?: error("type $this classified as a non-class is used in the schema")

      #set ( $type = ${types.getOrDefault($field,${types.getOrDefault($field.type,$field.type)})} )
      #if ( $type == "boolean" || $type == "Boolean" )
        #set ( $pfx = "is" )
      #else
        #set ( $pfx = "get" )
      #end
      #if ( $field.type == "java.util.List" || $field.type == "java.util.Properties" )
    @Nonnull
      #end
    public ${type} ${pfx}${cap}() {

      #set ( $def = ${field.defaultValue} )
      #if ( $field.type == "String" )
        #if ( ! $def )
            writeTag("$fieldTagName", null, ${classLcapName}.get${fieldCapName}(), serializer);
        #else
            writeTag("$fieldTagName", "${def}", ${classLcapName}.get${fieldCapName}(), serializer);
        #end
      #elseif ( $field.type == "boolean" || $field.type == "Boolean" )
        #if ( ${def} == "true" )

        }
        else -> arguments.any { typeProjection ->
            // A star projection type (lazily) built by type parameter will be yet another type with a star projection,
            // resulting in stack overflow if we keep checking allowed type parameter descriptors
            !typeProjection.isStarProjection &&
                    typeProjection.type.hasReferenceOtherThan(allowedTypeParameterDescriptors)
        }
    }
}

/**

     * Caches the computed `readObject` method hierarchies during decoding because [ReadContext.decode] might
     * be called multiple times for the same type.
     */
    private
    fun readObjectMethodHierarchyForDecoding(type: Class<*>): List<Method> =
        readObjectHierarchy.computeIfAbsent(type) {
            readObjectMethodHierarchyFrom(it.allMethods())
        }
}


internal
fun Method.isReadResolve() =

    override fun substituteType(type: ConeKotlinType): ConeKotlinType? {
        if (type !is ConeClassLikeType) return null

        val hasStableName = type.classId?.isLocal == true
        if (!hasStableName) {
            // Make sure we're not going to expand type argument over and over again.
            // If so, i.e., if there is a recursive type argument, return the current, non-null [type]

    }
}

/**
 *  The left hand side of a `::` is regarded as used unless it refers to a type.
 *  We decide that the LHS is a type reference by checking if the left hand
 *  side is a (qualified) name, and, in case it _is_, resolving that name.
 *
 *  If it resolves to a non-class declaration, it does _not_ refer to a type.
 */
private fun doesDoubleColonUseLHS(lhs: PsiElement): Boolean {

      #set ( $fieldCapName = $Helper.capitalise( $field.name ) )
            else if ("$fieldTagName".equals(name)) {
      #if ( $field.type == "String" )
                ${classLcapName}.${field.name}(interpolatedTrimmed(value, "$fieldTagName"));
      #elseif ( $field.type == "boolean" || $field.type == "Boolean" )