* that "matches" the original interceptor's signature as if it was an extension (i.e. receiver is
 * transformed to the first argument, and the callable kind becomes static). For Groovy properties,
 * the name of the callable is also transformed from "foo" to "getFoo".
 * It is possible to specify the custom name for the extension implementation, if needed.
 */
public @interface WithExtensionReferences {

     * Base class implementation applies the {@link ClassTransform} to the code.
     *
     * @param builder the builder for the transformed output
     * @param classEntry the entry to process
     * @throws IOException if reading or writing entry fails
     */

	//
	// A nil error means that all of the transformed bytes (whether freshly
	// transformed from src or left over from previous Transform calls)
	// were written to dst. A nil error can be returned regardless of
	// whether atEOF is true. If err is nil then nSrc must equal len(src);
	// the converse is not necessarily true.
	//
	// ErrShortDst means that dst was too short to receive all of the

        transformer.transform('original') == 'b'

    }

    def 'can use a Closure as a Transformer'() {
        when:
        transformer.add { it + ' transformed'}

        then:
        transformer.transform('original') == 'original transformed'
    }

    def 'uses original object when Closure returns null'() {
        when:
        transformer.add { null }

        then:

  }
  if (!inp.node_name().empty()) {
    return NodeBuilder::NodeOut(inp.node_name(), inp.index(), inp.data_type());
  }
  auto transformed = Input{
      Const(scope.NewSubScope("Const"), Input::Initializer(inp.tensor()))};
  return NodeBuilder::NodeOut{transformed.node(), transformed.index()};
}

std::vector<NodeBuilder::NodeOut> AsNodeOutList(const Scope& scope,

            return Providers.notDefined();
        }

        // Note, that the potential side effect of the transformed provider
        // is going to be executed before this fixed side effect.
        // It is not possible to preserve linear execution order in the general case,
        // as the transformed provider can have side effects hidden under other wrapping providers.

        encoder.writeSmallInt(transformed.getConfigurationNames().size());
        for (String configurationName: transformed.getConfigurationNames()) {
            ConfigurationMetadata configuration = transformed.getConfiguration(configurationName);

        this.modelRegistry = modelRegistry;
        this.ruleFactory = new ClosureBackedRuleFactory(relativeFilePathResolver);
    }

    /**
     * Invoked by transformed DSL configuration rules
     */
    public void configure(String modelPathString, Closure<?> closure) {
        ModelPath modelPath = ModelPath.path(modelPathString);

                    to.attribute(artifactType, 'size')
                }
            }

            def transformed = configurations.compile.incoming.artifactView { attributes.attribute(artifactType, 'size') }.files

            task resolve(type: ShowFilesTask) {
                inFiles.from(transformed)
            }

            abstract class MakeSize implements TransformAction<None> {
                @InputArtifact

                        println "Transformed artifact: \${it.file.name} (\${it.id.componentId}), location: \${it.file.absolutePath}"
                    }
                }
            }
        """
        expect:
        execute(buildA, "resolve")
        assertTaskExecuted(":buildB", ":jar")
        assertTaskExecuted(":buildC", ":jar")

        outputContains("Transformed artifact: buildB-1.0.jar.xform (project :buildB)")