} catch (ComponentLookupException e) {
                throw new RuntimeException(e);
            }
        });
        injector.bindScope(MojoExecutionScoped.class, () -> {
            try {
                return containerProvider.get().lookup(MojoExecutionScope.class);
            } catch (ComponentLookupException e) {
                throw new RuntimeException(e);
            }
        });

     * <p>
     * Throwing the exception from this method aborts the transformation but doesn't affect class loading. The caller
     * (the agent) will catch all throwables thrown by this method and forward them to {@link #transformFailed(String, Throwable)}.
     * <p>
     * The {@code classfileBuffer} may be already modified by other Java agents.
     * <p>

                    is ResolutionBackedFileCollectionSpec -> artifactSetConverter.asFileCollection(element.displayName, element.lenient, element.elements)
                    is BeanSpec -> element.bean
                    else -> throw IllegalArgumentException("Unexpected item $element in file collection contents")
                }
            }
        )
    }
}


private

        }

        String getGroovy(List<String> cmd) {
            throw new UnsupportedOperationException()
        }

        String getJava(List<String> cmd) {
            throw new UnsupportedOperationException()
        }

        String getKotlin(List<String> cmd) {
            throw new UnsupportedOperationException()
        }

        @Override
        String toString() {

        when (val symbolKind = symbolKind) {
            KaSymbolKind.LOCAL ->
                throw CanNotCreateSymbolPointerForLocalLibraryDeclarationException(classId?.asString() ?: name.asString())

            KaSymbolKind.CLASS_MEMBER, KaSymbolKind.TOP_LEVEL -> KaFirClassLikeSymbolPointer(classId!!, KaTypeAliasSymbol::class)
            else -> throw UnsupportedSymbolKind(this::class, symbolKind)
        }
    }

                        Class<?> clazz = classLoader.loadClass(line);
                        bindImplicit(clazz);
                    }
                }
            }
        } catch (Exception e) {
            throw new DIException("Error while discovering DI classes from classLoader", e);
        }
        return this;
    }

    public Injector bindScope(Class<? extends Annotation> scopeAnnotation, Scope scope) {

 * limitations under the License.
 */

package org.gradle.api;

import org.gradle.internal.exceptions.Contextual;

/**
 * A <code>InvalidUserCodeException</code> is thrown when user-provided code cannot be executed.
 */
@Contextual
public class InvalidUserCodeException extends GradleException {
    public InvalidUserCodeException() {
    }

import static Cast.cast

class CastTest extends Specification {

    def "casting"() {
        given:
        def arg = "1"

        when:
        cast(Integer, arg)

        then:
        def e = thrown(ClassCastException)
        e.message == "Failed to cast object $arg of type ${arg.class.name} to target type ${Integer.name}"

        when:
        def result = cast(CharSequence, arg)

        then:

 * limitations under the License.
 */

package org.gradle.api;

import javax.annotation.Nullable;

/**
 * <p><code>GradleException</code> is the base class of all exceptions thrown by Gradle.</p>
 */
public class GradleException extends RuntimeException {
    public GradleException() {
        super();
    }

    public GradleException(String message) {
        super(message);
    }

                        return !element.getBaseVersion().equals(excludedVersion);
                    }
                });
            } else {
                throw new RuntimeException(String.format("Unsupported version range '%s' specified in constraint '%s'. Supported formats: '>=nnn', '>nnn', '<=nnn', '<nnn', '!nnn' or space-separate patterns", value, constraint));
            }
        }