}

        val candidateDeclaration = candidateSymbol.firSymbol.fir as FirMemberDeclaration

        val positionModule = firResolveSession.moduleProvider.getModule(position)
        val candidateModule = candidateDeclaration.llFirModuleData.ktModule

        val effectiveSession = if (positionModule is KtDanglingFileModule && candidateModule != positionModule) {

        project.getExtensions().add(SwiftXCTestSuite.class, "xctest", testSuite);
        project.getComponents().add(testSuite);

        // Setup component
        testSuite.getModule().set(GUtil.toCamelCase(project.getName() + "Test"));

        final DefaultSwiftXCTestSuite testComponent = testSuite;

            if (dependencyNotation instanceof IvyModule) {
                module = dependencyNotation
            }
            createSpecs()
        }

        IvyModule getModule() {
           super.module
        }

        void validate() {
            singleValidation(true, withModuleMetadataSpec)
            singleValidation(false, withoutModuleMetadataSpec)
        }

        }

        @Override
        public boolean isSatisfiedBy(ComponentSelection selection) {
            return selection.getCandidate().getGroup().equals(target.getGroup()) && selection.getCandidate().getModule().equals(target.getName());
        }
    }

        return KaSymbolOrigin.SOURCE
    }

    private fun getHandler(useSiteElement: KtElement): KaFe10AnalysisHandlerExtension {
        val project = useSiteElement.project
        val ktModule = ProjectStructureProvider.getModule(project, useSiteElement, contextualModule = null)
        return KaFe10AnalysisHandlerExtension.getInstance(project, ktModule)
    }

    private fun <T : Any> T?.orThrowResolutionNotPerformedError(): T =

            DefaultDependencyConstraint dependencyConstraint = instantiator.newInstance(DefaultDependencyConstraint.class, notation.getModule(), notation.getVersionConstraint());
            if (notation instanceof DependencyVariant) {
                dependencyConstraint.setAttributesFactory(attributesFactory);

        this.id = id;
        this.resolver = resolver;
        this.targetModule = resolveState.getModule(targetModuleId);
        if (versionByAncestor) {
            dependencyReasons.add(ComponentSelectionReasons.BY_ANCESTOR);
        }
        update(dependencyState);
        this.dependencyState = dependencyState;

    }

    private void writeComponentIdentifier(Encoder encoder, ModuleComponentIdentifier platformOwner) throws IOException {
        encoder.writeString(platformOwner.getGroup());
        encoder.writeString(platformOwner.getModule());
        encoder.writeString(platformOwner.getVersion());
    }

    private AbstractRealisedModuleComponentResolveMetadata assertRealized(ModuleComponentResolveMetadata metadata) {

        ModuleIdentifier module = component.getModuleVersionId().getModule();

        // artifactsToResolve are those not excluded by their owning module
        boolean hasExcludedArtifact = false;

                if (rcs instanceof ModuleComponentSelector) {
                    ModuleComponentSelector requested = (ModuleComponentSelector) rcs;
                    if (requested.getGroup().equals(group) && requested.getModule().equals(module)) {
                        return getModuleVersionId(selected);
                    }
                } else if (rcs instanceof ProjectComponentSelector) {