} else {
                ExternalDependency extDep = (ExternalDependency) dep;
                dependenciesBuilder.dependency(dep.getConfiguration(), null, BuildInitDependency.of(extDep.getGroupId(), extDep.getModule(), extDep.getVersion()));
            }
        }
    }

    private void globalExclusions(MavenProject project, BuildScriptBuilder builder) {

                            withPsiEntry("psi", psi, analysisSession::getModule)
                        }
                }
                is KtExpression -> psi
                else -> errorWithAttachment("unexpected PSI ${psi::class} for FirImplicitInvokeCall") {
                    withPsiEntry("psi", psi, analysisSession::getModule)
                }
            }

            DefaultModuleRegistry registry = new DefaultModuleRegistry(null);
            return registry.getModule("gradle-tooling-api-provider").getAllRequiredModulesClasspath();
        }
    }

                    ModuleComponentSelector selector = dependency.getSelector();
                    return new ModuleVersionResolveException(selector, () -> "Failed to list versions for " + selector.getGroup() + ":" + selector.getModule() + ".", cause);
                });
        }

        @Override

        VersionConstraint versionConstraint = DefaultMutableVersionConstraint.withVersion(lockedVersion);
        return DefaultModuleComponentSelector.newSelector(DefaultModuleIdentifier.newId(lockIdentifier.getGroup(), lockIdentifier.getModule()), versionConstraint);
    }

    @Override
    public DependencyLockingState loadLockState(String lockId, DisplayName lockOwner) {
        recordUsage();
        loadLockState();

                return ImmutableList.of(new DefaultModuleComponentArtifactMetadata(metadata.getId(), new DefaultIvyArtifactName(metadata.getId().getModule(), type, type),
                    metadata.artifact("jar", "jar", null)));
            }
        }
    }

    private final NamedObjectInstantiator objectInstantiator;

        ModuleComponentIdentifier mci = verification.getComponentId();
        writer.startElement(COMPONENT);
        writeAttribute(GROUP, mci.getGroup());
        writeAttribute(NAME, mci.getModule());
        writeAttribute(VERSION, mci.getVersion());
        writeArtifactVerifications(verification.getArtifactVerifications());
        writer.endElement();
    }

            return State.RESOLVED;
        } else {
            return State.UNRESOLVED;
        }
    }

    @Override
    public Module getModule() {
        return metaDataProvider.getModule();
    }

    @Override
    public boolean isVisible() {
        return visible;
    }

    @Override
    public Configuration setVisible(boolean visible) {

        then:
        project.hasProperty(propertyName)
        child1.hasProperty(propertyName)
    }

    def properties() {
        given:
        dependencyMetaDataProviderMock.getModule() >> Stub(Module)
        serviceRegistryMock.get(ServiceRegistryFactory) >> Stub(ServiceRegistryFactory)

        when:
        project.ext.additional = 'additional'

        then:

        this.visitState = visitState;
    }

    public List<NodeState> getNodes() {
        return nodes;
    }

    public ModuleResolveState getModule() {
        return module;
    }

    public void selectAndRestartModule() {
        module.replaceWith(this);
    }

    @Override
    @Nullable