collector.checkResolveCall(bindingContext.get(BindingContext.LOOP_RANGE_ITERATOR_RESOLVED_CALL, expression.loopRange))
                collector.checkResolveCall(bindingContext.get(BindingContext.LOOP_RANGE_HAS_NEXT_RESOLVED_CALL, expression.loopRange))
                collector.checkResolveCall(bindingContext.get(BindingContext.LOOP_RANGE_NEXT_RESOLVED_CALL, expression.loopRange))
            }

        if (descriptor !is VariableDescriptorWithAccessors) return

        descriptor.accessors.forEach { accessor ->
            collector.checkResolveCall(bindingContext.get(BindingContext.DELEGATED_PROPERTY_RESOLVED_CALL, accessor))
        }
    }

        )
        return candidates.filter { overloadCandidate ->
            when (overloadCandidate.candidate.lowestApplicability) {
                CandidateApplicability.RESOLVED -> true
                CandidateApplicability.K2_SYNTHETIC_RESOLVED -> true // SAM constructor call
                else -> false
            }
        }
    }

    private fun findCandidatesForPropertyAccess(

            "type": "fess_simplified_chinese_tokenizer"
        },
        "vietnamese_tokenizer": {
            "type": "fess_vietnamese_tokenizer",
            "sentence_detector": false,
            "ambiguities_resolved": false
        },
        "unigram_tokenizer": {
          "type": "ngram",
          "min_gram": 1,
          "max_gram": 1,
          "token_chars": []
        },
        "unigram_search_tokenizer": {

     * @param scopesToCollect    The dependency scopes that should be collected, may be {@code null}.
     * @param scopesToResolve    The dependency scopes that should be collected and also resolved, may be {@code null}.
     * @param session            The current build session, must not be {@code null}.
     * @param ignorableArtifacts Artifacts that need not be resolved

        TypeToken.of(new TypeCapture<L>() {}.capture()));
    assertAssignable(TypeToken.of(new TypeCapture<L>() {}.capture()), new TypeToken<List<R>>() {});
  }

  public void testisSupertypeOf_resolved() {
    assertFalse(Assignability.of().isAssignable());
    assertTrue(new Assignability<Integer, Integer>() {}.isAssignable());
    assertTrue(new Assignability<Integer, Object>() {}.isAssignable());

import org.apache.maven.api.model.Parent;
import org.apache.maven.api.model.Repository;

/**
 * Resolves a POM from its coordinates. During the build process, the
 * {@link org.apache.maven.api.services.ModelBuilder} will add any relevant repositories to the model resolver. In
 * other words, the model resolver is stateful and should not be reused across multiple model building requests.
 *
 */

        TypeToken.of(new TypeCapture<L>() {}.capture()));
    assertAssignable(TypeToken.of(new TypeCapture<L>() {}.capture()), new TypeToken<List<R>>() {});
  }

  public void testisSupertypeOf_resolved() {
    assertFalse(Assignability.of().isAssignable());
    assertTrue(new Assignability<Integer, Integer>() {}.isAssignable());
    assertTrue(new Assignability<Integer, Object>() {}.isAssignable());

        // The root artifact may, or may not be resolved so we need to check before we attempt to resolve.
        // This is often an artifact like a POM that is taken from disk and we already have hold of the
        // file reference. But this may be a Maven Plugin that we need to resolve from a remote repository
        // as well as its dependencies.

    }

    /**
     * Resolves {@code var} using the encapsulated type mapping. If it maps to yet another
     * non-reified type or has bounds, {@code forDependants} is used to do further resolution, which
     * doesn't try to resolve any type variable on generic declarations that are already being
     * resolved.
     *
     * <p>Should only be called and overridden by {@link #resolve(TypeVariable)}.
     */