*
 * Inner classes are included because they are accessible from a value of the outer class. For example:
 *
 * ```
 * class Outer {
 *     inner class Inner
 * }
 *
 * fun foo() {
 *     val outer = Outer()
 *     outer.Inner()
 * }
 * ```
 *

        val bindingContext = analysisContext.analyze(psi, AnalysisMode.PARTIAL)
        bindingContext[BindingContext.CLASS, psi]
    }

    override val isInner: Boolean
        get() = withValidityAssertion { psi.hasModifier(KtTokens.INNER_KEYWORD) }

    override val isData: Boolean
        get() = withValidityAssertion { psi.hasModifier(KtTokens.DATA_KEYWORD) }

    override val isInline: Boolean

        List<String> details = new ArrayList<>();

        org.eclipse.aether.graph.DependencyNode winner =
                (org.eclipse.aether.graph.DependencyNode) node.getData().get(ConflictResolver.NODE_DATA_WINNER);
        String winnerVersion = winner != null ? winner.getArtifact().getBaseVersion() : null;
        boolean included = (winnerVersion == null);

        List<String> details = new ArrayList<>();

        org.eclipse.aether.graph.DependencyNode winner =
                (org.eclipse.aether.graph.DependencyNode) node.getData().get(ConflictResolver.NODE_DATA_WINNER);
        String winnerVersion = winner != null ? winner.getArtifact().getBaseVersion() : null;
        boolean included = (winnerVersion == null);

) : KtNamedClassOrObjectSymbol(), KtFe10DescMemberSymbol<ClassDescriptor> {
    override val name: Name
        get() = withValidityAssertion { descriptor.name }

    override val isInner: Boolean
        get() = withValidityAssertion { descriptor.isInner }

    override val isData: Boolean
        get() = withValidityAssertion { descriptor.isData }

    override val isInline: Boolean

type PartialAddError struct {
	inner error
}

func (e *PartialAddError) Error() string {
	return fmt.Sprintf("%s: %v", ErrPartialAdd.Error(), e.inner)
}

func (e *PartialAddError) Unwrap() []error {
	return []error{ErrPartialAdd, e.inner}
}

func NewErrPartialAdd(err error) *PartialAddError {
	return &PartialAddError{
		inner: err,
	}

    SettableFuture<Object> async = SettableFuture.create();
    SettableFuture<Object> inner = SettableFuture.create();
    async.setFuture(inner);
    async.cancel(true);
    assertTrue(inner.isCancelled());
    assertTrue(inner.wasInterrupted());
    assertThrows(CancellationException.class, () -> inner.get());
  }

  public void testCancel_resultCancelsInner() throws Exception {

    SettableFuture<Object> async = SettableFuture.create();
    SettableFuture<Object> inner = SettableFuture.create();
    async.setFuture(inner);
    async.cancel(true);
    assertTrue(inner.isCancelled());
    assertTrue(inner.wasInterrupted());
    assertThrows(CancellationException.class, () -> inner.get());
  }

  public void testCancel_resultCancelsInner() throws Exception {

  @SuppressWarnings("unchecked")
  protected <E> NavigableSet<E> create() {
    TestSet<E> inner =
        new TestSet<>(new TreeSet<E>((Comparator<E>) Ordering.natural().nullsFirst()), null);
    NavigableSet<E> outer = Synchronized.navigableSet(inner, null);
    inner.mutex = outer;
    return outer;
  }

  static class TestSet<E> extends SynchronizedSetTest.TestSet<E> implements NavigableSet<E> {

		},
		{
			name: "INNER JOIN",
			join: clause.Join{
				Type:  clause.InnerJoin,
				Table: clause.Table{Name: "user"},
				ON: clause.Where{
					Exprs: []clause.Expression{clause.Eq{clause.Column{Table: "user_info", Name: "user_id"}, clause.PrimaryColumn}},
				},
			},
			sql: "INNER JOIN `user` ON `user_info`.`user_id` = `users`.`id`",
		},
		{
			name: "CROSS JOIN",