if (hasLegacyConfigs) {
                message("Re-run this report with the '--all' flag to include legacy " + spec.getReportedTypeAlias() + "s (legacy = consumable and resolvable).");
            }
        } else {
            writeResults(data, nonLegacyConfigs);
        }
    }

    private void writeResults(ConfigurationReportModel data, List<ReportConfiguration> configs) {

            }

            byIdentity.put(VariantIdentity.from(configuration), configuration);
        });

        return new VerificationReport(byIdentity);
    }

    /**
     * Consumable, non-resolvable, non-default configurations with attributes must have unique attributes.
     */
    private static boolean mustHaveUniqueAttributes(Configuration configuration) {
        return configuration.isCanBeConsumed() &&

            task jar3(type: Jar) {}

            configurations {
                consumable("con") {
                    outgoing.artifact(tasks.jar1)
                }
                resolvable("res") {
                    outgoing.artifact(tasks.jar2)
                }
                dependencyScope("dep") {
                    outgoing.artifact(tasks.jar3)
                }
            }

                role
        );
        instance.addMutationValidator(rootComponentMetadataBuilder.getValidator());
        return instance;
    }

    /**
     * Creates a new locked resolvable configuration instance.
     */
    DefaultResolvableConfiguration createResolvable(
        String name,
        ConfigurationsProvider configurationsProvider,

     * The passed notation should conform these constraints:
     * <ul>
     *     <li>If a file notation is passed, it should be a single file.</li>
     *     <li>If it's a resolvable dependency, it should resolve to a single file.</li>
     * </ul>
     *
     * <p>
     * If the notation doesn't conform these constraints, an exception will be thrown at configuration time.
     *

                super.visitErrorResolvedQualifier(errorResolvedQualifier)
            }

            private fun processErrorNameReference(resolvable: FirResolvable) {
                val nameReference = resolvable.calleeReference as? FirErrorNamedReference ?: return
                val name = nameReference.unresolvedName ?: return
                unresolvedNames += name
            }

        !forbidden(alternatives)    || errorOutput.contains("Resolving dependency configuration '$configuration' is not allowed as it is defined as 'canBeResolved=false'.\nInstead, a resolvable ('canBeResolved=true') dependency configuration that extends '$configuration' should be resolved.")

 * the client and may be necessary for proper operation.
 * <p>
 * This class should be used in favor of <tt>InetAddress</tt> to resolve
 * hostnames on LANs and WANs that support a mixture of NetBIOS/WINS and
 * DNS resolvable hosts.
 */

public class UniAddress implements Address {

    /**
     * Check whether a hostname is actually an ip address
     * 
     * @param hostname
     * @return whether this is an IP address

                compilation("first")
            }}
        """

        buildFile << """
            configurations {
                dependencyScope("someConf")
                resolvable("resolvableConf") {
                    extendsFrom(someConf)
                }
            }

            firstChildComponent.withVariantsFromConfiguration(configurations.firstRuntimeElements) {

This can lead to confusing circular dependency graphs, as the configuration being resolved is used for two different purposes.

To avoid this problem, plugins should mark all resolvable configurations as `canBeConsumed=false` or use the `resolvable(String)` configuration factory method when creating configurations meant for resolution.