public Set<Feature<? super Collection>> getImpliedFeatures() {
    return implied;
  }

  public int getNumElements() {
    if (numElements == null) {
      throw new IllegalStateException(
          "A compound CollectionSize doesn't specify a number of elements.");
    }
    return numElements;
  }

  @Retention(RetentionPolicy.RUNTIME)
  @Inherited
  @TesterAnnotation
  public @interface Require {

  public Set<Feature<? super Collection>> getImpliedFeatures() {
    return implied;
  }

  public int getNumElements() {
    if (numElements == null) {
      throw new IllegalStateException(
          "A compound CollectionSize doesn't specify a number of elements.");
    }
    return numElements;
  }

  @Retention(RetentionPolicy.RUNTIME)
  @Inherited
  @TesterAnnotation
  public @interface Require {

        require(packageSymbol is KtFe10PackageSymbol)
        val packageFragments = analysisContext.resolveSession.packageFragmentProvider.packageFragments(packageSymbol.fqName)
        val scopeDescription = "Compound scope for package \"${packageSymbol.fqName}\""
        val chainedScope = ChainedMemberScope.create(scopeDescription, packageFragments.map { it.getMemberScope() })

  private static final Ordering<List<Class<?>>> ORDERING_BY_CONSTRUCTOR_PARAMETER_LIST =
      Ordering.natural()
          .onResultOf((List<Class<?>> params) -> params.contains(String.class))
          .compound(
              Ordering.natural()
                  .onResultOf((List<Class<?>> params) -> params.contains(Throwable.class)))
          .reverse();

    assertThat("hello".map()).isEqualTo("hello")
    assertThat("hello-world".map()).isEqualTo("hello-world")
    assertThat("HELLO".map()).isEqualTo("hello")
    assertThat("Hello".map()).isEqualTo("hello")

    // These compound characters map their its components.
    assertThat("¼".map()).isEqualTo("1⁄4")
    assertThat("™".map()).isEqualTo("tm")
  }

  /** Confirm the compact table satisfies is documented invariants. */

                        unwrappedPsi.operationToken in OperatorConventions.EQUALS_OPERATIONS)
            ) {
                // TODO: Handle compound assignment
                handleAsFunctionCall(this, unwrappedPsi)?.toKtCallCandidateInfos()?.let { return@with it }
            }

        if (deparenthesize(callExpression.calleeExpression) != calleeExpression) return null
        return callExpression
    }

    /**
     * For `=` and compound access like `+=`, `-=`, `*=`, `/=`, `%=`, the LHS of the binary expression is not a complete call. Hence we
     * find the containing binary expression and resolve that instead.
     *

#       requires all of these POSIX shell features:
#         * functions;
#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
#         * compound commands having a testable exit status, especially «case»;
#         * various built-in commands including «command», «set», and «ulimit».
#
#   Important for patching:
#

    // to fill dummy parameter values for them. Ties are broken by name then by the string form of
    // the parameter list.
    return BY_NUMBER_OF_PARAMETERS
        .compound(BY_METHOD_NAME)
        .compound(BY_PARAMETERS)
        .immutableSortedCopy(factories);
  }

  private List<Object> getDummyArguments(Invokable<?, ?> invokable)
      throws ParameterNotInstantiableException {

    // to fill dummy parameter values for them. Ties are broken by name then by the string form of
    // the parameter list.
    return BY_NUMBER_OF_PARAMETERS
        .compound(BY_METHOD_NAME)
        .compound(BY_PARAMETERS)
        .immutableSortedCopy(factories);
  }

  private List<Object> getDummyArguments(Invokable<?, ?> invokable)
      throws ParameterNotInstantiableException {