Type originalType = accessor.originalType;
        return new CallInterceptionRequestImpl(
            extractCallableInfo(GROOVY_PROPERTY_GETTER, method, originalType, accessor.propertyName, parameters),
            extractImplementationInfo(method, originalType, accessor.methodName, "get", Collections.emptyList()),
            extras
        );
    }

                @ReplacesEagerProperty${PRIMITIVE_TYPES.contains(originalType) ? "(originalType = ${originalType}.class)" : ""}
                public abstract $upgradedType getProperty();
            }
        """

        when:
        Compilation compilation = compile(givenSource)

        then:
        boolean hasSuppressWarnings = originalType in ["List", "Map", "Set"]

    /**
     * The name of the accessor, e.g. `getDestinationDir` or `setDestinationDir`
     */
    String name();

    /**
     * See {@link ReplacesEagerProperty#originalType()}
     */
    Class<?> originalType() default DefaultValue.class;

    /**
     * See {@link ReplacesEagerProperty#fluentSetter()}
     */
    boolean fluentSetter() default false;

        }

        fun addProperty(kClass: KClass<*>, property: DataProperty, originalType: KType) {
            properties.getOrPut(kClass) { mutableMapOf() }[property.name] = property
            propertyOriginalTypes.getOrPut(kClass) { mutableMapOf() }[property.name] = originalType
        }

        fun claimFunction(kClass: KClass<*>, kFunction: KFunction<*>) {

    override suspend fun ReadContext.decode(): IsolatedJavaSerializedValueSnapshot? {
        val implementationHash = read() as HashCode?
        val originalType = readClass()
        val binary = readBinary()
        return IsolatedJavaSerializedValueSnapshot(implementationHash, binary, originalType)
    }

     * MapProperty[K, V] -> original type becomes Map[K, V]
     * ListProperty[T] -> original type becomes List[T]
     * ConfigurableFileCollection -> original type becomes FileCollection
     */
    Class<?> originalType() default DefaultValue.class;

    /**
     * Whether the setter accessor for property was fluent
     */
    boolean fluentSetter() default false;

    /**

                public abstract Property<String> getTargetCompatibility();
                @ReplacesEagerProperty
                public abstract Property<String> getSourceCompatibility();
                @ReplacesEagerProperty(originalType = int.class)
                public abstract Property<Integer> getMaxErrors();
            }
        """

        when:
        Compilation compilation = compile(givenSource)

        then:

				}
				original[k], ok = removeDirectives(patchV)
				if !ok {
					delete(original, k)
				}
			}
			continue
		}

		originalType := reflect.TypeOf(original[k])
		patchType := reflect.TypeOf(patchV)
		if originalType != patchType {
			if !isDeleteList {
				if mergeOptions.IgnoreUnmatchedNulls {
					discardNullValuesFromPatch(patchV)
				}

    original_type = field.type_
    if is_dataclass(original_type) and hasattr(original_type, "__pydantic_model__"):
        original_type = original_type.__pydantic_model__
    use_type = original_type
    if lenient_issubclass(original_type, BaseModel):
        original_type = cast(Type[BaseModel], original_type)
        use_type = cloned_types.get(original_type)
        if use_type is None:

    }

    interface UncheckedCast : KaFirDiagnostic<KtBinaryExpressionWithTypeRHS> {
        override val diagnosticClass get() = UncheckedCast::class
        val originalType: KaType
        val targetType: KaType
    }

    interface UselessIsCheck : KaFirDiagnostic<KtElement> {
        override val diagnosticClass get() = UselessIsCheck::class