} else {
                    inputs.set(i, input.inScope(ModelPath.ROOT));
                }
            }
        }

        private ModelReference<?> mapSubject(ModelReference<?> subject, ModelPath targetPath) {
            if (subject.getPath() == null) {
                return subject.inScope(targetPath);
            } else {

    }

    public ModelNode.State getState() {
        return state;
    }

    public boolean isUntyped() {
        return type.equals(ModelType.UNTYPED);
    }

    public ModelReference<T> inScope(ModelPath scope) {
        if (scope.equals(this.scope)) {
            return this;
        }
        return Cast.uncheckedCast(new ModelReference<T>(path, type, scope, state, description));
    }

        projectBuilder = getContainer().lookup(ProjectBuilder.class, "classpath");
    }

    @Test
    void testProjectClasspath() throws Exception {
        File f = getFileForClasspathResource(dir + "project-with-scoped-dependencies.xml");

        MavenProject project = getProjectWithDependencies(f);

        Artifact artifact;

        assertNotNull(project, "Test project can't be null!");

import static java.util.Collections.singleton;
import static org.apache.maven.internal.impl.Lifecycles.phase;
import static org.apache.maven.internal.impl.Lifecycles.plugin;

/**
 * TODO: this is session scoped as SPI can contribute.
 */
@Named
@Singleton
public class DefaultLifecycleRegistry implements LifecycleRegistry {

    private final List<LifecycleProvider> providers;

    public DefaultLifecycleRegistry() {

        Artifact artifact = request.getArtifact();

        //
        // If we have a system scoped artifact then we do not want any searching in local or remote repositories
        // and we want artifact resolution to only return the system scoped artifact itself.
        //
        if (artifact.getScope() != null && artifact.getScope().equals(Artifact.SCOPE_SYSTEM)) {

// approach. You are expected to fall back to the general approach if this
// function fails.
func (enc *Encoder) concreteMethod(meth *types.Func) (Path, bool) {
	// Concrete methods can only be declared on package-scoped named types. For
	// that reason we can skip the expensive walk over the package scope: the
	// path will always be package -> named type -> method. We can trivially get

	// that if "foo := bar" is unused and removed, we can then detect if
	// "bar" becomes unused as well.
	defining *object
}

// scoped opens a new scope when called, and returns a function which closes
// that same scope. When a scope is closed, unused variables are recorded.
func (u *unusedInspector) scoped() func() {
	outer := u.scope
	u.scope = &scope{outer: outer, objects: map[string]*object{}}
	return func() {

    }

    def "constructors do not need to be public but do need to be annotated"() {
        expect:
        instantiator.newInstance(HasPrivateConstructor, "param") != null
    }

    def "class can be package scoped"() {
        expect:
        instantiator.newInstance(PackageScopedClass) != null
    }

    def "selects annotated constructor when class has multiple constructors and only one is annotated"() {
        when:

- Cannot be a parameterized type."""
    }


    @Managed
    static abstract class WithInstanceScopedField {
        private String name
        private int age
    }

    def "instance scoped fields are not allowed"() {
        when:  extract WithInstanceScopedField
        then: def ex = thrown InvalidManagedTypeException

        // 2) Repository system session-scoped workspace reader (contains ide and exec request reader)
        for (WorkspaceReader repoWorkspaceReader : chainedWorkspaceReader.getReaders()) {
            if (repoWorkspaceReader != null && repoWorkspaceReader != reactorReader) {
                workspaceReaders.add(repoWorkspaceReader);
            }
        }
        // 3) .. n) Project-scoped workspace readers