*
     * @see org.gradle.api.artifacts.dsl.DependencyHandler#registerTransform(Class, Action)
     */
    AttributeContainer getFrom();

    /**
     * Attributes that match the variant that is produced.
     *
     * @see org.gradle.api.artifacts.dsl.DependencyHandler#registerTransform(Class, Action)
     */
    AttributeContainer getTo();

    /**
     * The parameters for the transform action.
     *

// the test case below, at the call to b.F2(b.T{}) in c.go, the
// interface method set is sorted as { a.m(); b.m() }.
//
// However, while compiling package b, its package path is set to "",
// so the code produced for F2 uses { b.m(); a.m() } as the method set
// order. So again, it ends up calling the wrong method.
//
// Also, this function is marked noinline because it's critical to the

     *
     * <ul>
     *     <li>{@link org.gradle.api.artifacts.component.ProjectComponentIdentifier} for those component instances which are produced by the current build.</li>
     *     <li>{@link org.gradle.api.artifacts.component.ModuleComponentIdentifier} for those component instances which are found in some repository.</li>
     * </ul>
     *

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.nativeplatform.fixtures.binaryinfo
/**
 * Binary information for GCC produced binaries. It approximate features required by our tests using dumpbin.exe from Visual Studio. It's not the right solution, but it works for most cases.
 */
class DumpbinGccProducedBinaryInfo extends DumpbinBinaryInfo {

    // This tests current behaviour, not desired behaviour
    @UnsupportedWithConfigurationCache(because = "Task does not declare that it uses the transform outputs")
    def "can consume transform outputs produced by another project without declaring this access"() {
        createDirs("a", "b", "sneaky")
        settingsFile << """
            include 'a', 'b', 'sneaky'
        """
        setupBuildWithColorTransformImplementation()

/**
 * A container of {@link Report} objects, that represent potential reports.
 * <p>
 * Things that produce reports (typically tasks) expose a report container that contains {@link Report} objects for each
 * possible report that they can produce. Each report object can be configured individually, including whether or not it should
 * be produced by way of its {@link Report#getRequired()} required} property.
 * <p>

        if (mainArtifact != null && !((PublicationArtifactInternal) mainArtifact).shouldBePublished()) {
            throw new IllegalStateException("Artifact " + mainArtifact.getFile().getName() + " wasn't produced by this build.");
        }
        return mainArtifact;
    }

    public Set<MavenArtifact> getAdditionalArtifacts() {
        return allArtifacts.stream()

 public:
  // Constructs a diagnostic handler in a context. If propagate is true, then
  // diagnostics reported are also propagated back to the original diagnostic
  // handler.  If filter_stack is true, a reduced stack will be produced.

  explicit StatusScopedDiagnosticHandler(MLIRContext* context,
                                         bool propagate = false,
                                         bool filter_stack = false);

     */
    PlatformToolProvider select(NativeLanguage sourceLanguage, NativePlatformInternal targetMachine);

    /**
     * Returns a unique, opaque, output type for the output produced by this toolchain on the current operating system.
     */
    String getOutputType();

    void assertSupported();

    class Identifier {

import org.gradle.util.Path;

import javax.annotation.concurrent.ThreadSafe;

/**
 * A provider of dependency resolution metadata for local components produced by any build in the build tree.
 *
 * <p>In general, you should be using {@link LocalComponentRegistry} instead of this type, as it is scoped
 * to a build and will call the appropriate method on this provider.</p>
 */