}

    @Override
    public ImmutableAttributes compileScope(ImmutableAttributes original) {
        List<Object> key = ImmutableList.of(original, Usage.JAVA_API);
        return concatCache.computeIfAbsent(key, k -> {
            ImmutableAttributes result = original;
            result = concat(result, USAGE_ATTRIBUTE, new CoercingStringValueSnapshot(Usage.JAVA_API, objectInstantiator));

    public PluginDescriptor(PluginDescriptor original) {
        this.setGroupId(original.getGroupId());
        this.setArtifactId(original.getArtifactId());
        this.setVersion(original.getVersion());
        this.setGoalPrefix(original.getGoalPrefix());
        this.setInheritedByDefault(original.isInheritedByDefault());
        this.setName(original.getName());
        this.setDescription(original.getDescription());

internal
data class AccessorNameSpec(val original: String) {

    val kotlinIdentifier
        get() = original

    val stringLiteral by unsafeLazy {
        stringLiteralFor(original)
    }
}


internal
data class TypedAccessorSpec(
    val receiver: TypeAccessibility.Accessible,

        when:
        executeWithException(original)
        then:
        def ex = thrown type
        ex === original

        where:
        original << [
            new RuntimeException("lajos"),
            new Error("lajos"),
            new UncheckedIOException(new IOException("lajos"))
        ]
        type = original.class
    }

        return new CastingTransformer<O, I>(outputType);
    }

    //just returns the original object
    public static <T> Transformer<T, T> noOpTransformer() {
        return new Transformer<T, T>() {
            @Override
            public T transform(T original) {
                return original;
            }
        };
    }

    @Override
    public Version transform(String original) {
        return cache.computeIfAbsent(original, this::parse);
    }

    private Version parse(String original) {
        List<String> parts = new ArrayList<>();
        boolean digit = false;
        int startPart = 0;
        int pos = 0;
        int endBase = 0;
        int endBaseStr = 0;
        for (; pos < original.length(); pos++) {

    final T original

    ThreadLocalInterceptorSet(T original) {
        this.original = original
    }

    boolean isEmpty() {
        substitutions.get() == 0
    }

    void substituteForCurrentThread(T substitution) {
        if (threadLocalDecorators.get() != original) {

    /**
     * Overrides original type that will be used for generated code.
     * By default, the original type is determined from the lazy property type, e.g.:
     * Property[T] -> original type becomes T (also Property[Integer] -> Integer and not int)
     * RegularFileProperty -> original type becomes File
     * DirectoryProperty -> original type becomes File
     * MapProperty[K, V] -> original type becomes Map[K, V]

        return new CastingTransformer<O, I>(outputType);
    }

    //just returns the original object
    public static <T> InternalTransformer<T, T> noOpTransformer() {
        return new InternalTransformer<T, T>() {
            @Override
            public T transform(T original) {
                return original;
            }
        };
    }

        createFile(new File(cachesDir, "transforms-1/second/transformed/original/file"))
        createFile(new File(cachesDir, "transforms-2/first/transformed/instrumented/file"))
        createFile(new File(cachesDir, "transforms-2/first/transformed/original/file"))
        createFile(new File(cachesDir, "transforms-2/second/metadata.bin"))