override fun getEnumEntries(classSymbol: KaNamedClassOrObjectSymbol): List<KaEnumEntrySymbol> {
        val enumDescriptor = getSymbolDescriptor(classSymbol) as? ClassDescriptor ?: return emptyList()
        if (enumDescriptor.kind != ClassKind.ENUM_CLASS) {
            return emptyList()
        }

        val result = mutableListOf<KaEnumEntrySymbol>()

        for (entryDescriptor in enumDescriptor.unsubstitutedMemberScope.getContributedDescriptors()) {

     */
    default Iterable<Dependency> getCompileOnlyDependencies() {
        return Collections.emptyList();
    };

    /**
     * Returns the dependencies required only when executing the tests associated with this toolchain.
     */
    default Iterable<Dependency> getRuntimeOnlyDependencies() {
        return Collections.emptyList();
    };

    /**

    final override val typeParameters: List<KaTypeParameterSymbol>
        get() = withValidityAssertion { emptyList() }

    final override val contextReceivers: List<KaContextReceiver> get() = withValidityAssertion { emptyList() }

    public abstract val isDefault: Boolean
    public abstract val isInline: Boolean
    public abstract val isOverride: Boolean

// RUN: tf-mlir-translate -mlir-to-graphdef %s -o - | FileCheck %s

func.func @main() {
  tf_executor.graph {
    // CHECK:       key: "emptylist"
    // CHECK-NEXT:  value {
    // CHECK-NEXT:    list {
    // CHECK-NEXT:    }
    // CHECK-NEXT:  }
    // CHECK:       key: "typelist"
    // CHECK-NEXT:  value {
    // CHECK-NEXT:    list {
    // CHECK-NEXT:      type: DT_INT32
    // CHECK-NEXT:      type: DT_FLOAT
    // CHECK-NEXT:    }

            }

            val resolutionScope = unwrappedPsi.getResolutionScope(this) ?: return emptyList()
            val call = unwrappedPsi.getCall(this)?.let {
                if (it is CallTransformer.CallForImplicitInvoke) it.outerCall else it
            } ?: return emptyList()
            val dataFlowInfo = getDataFlowInfoBefore(unwrappedPsi)

    override fun getAllPossibleNames(): Set<Name> = withValidityAssertion {
        return emptySet()
    }

    override fun getPossibleCallableNames(): Set<Name> = withValidityAssertion {
        return emptySet()
    }

    override fun getPossibleClassifierNames(): Set<Name> = withValidityAssertion {
        return emptySet()
    }

    override fun getAllSymbols(): Sequence<KaDeclarationSymbol> = withValidityAssertion {

        return plusMinusConfigurations.containsKey(plusMinus) ? plusMinusConfigurations.get(plusMinus) : Collections.<Configuration>emptyList();
    }

    private Map<String, Collection<Configuration>> getPlusMinusConfigurations(IdeaModule ideaModule, GeneratedIdeaScope scope) {

 * limitations under the License.
 */

package org.gradle.test;

import static java.util.Collections.emptyList;

import java.util.List;

public class JavaClassWithStaticImport {
    List<String> getProperty() { return emptyList(); }

public class DefaultRedrawableLabel implements RedrawableLabel {
    private final Cursor writePos;  // Relative coordinate system
    private List<StyledTextOutputEvent.Span> spans = Collections.emptyList();
    private List<StyledTextOutputEvent.Span> writtenSpans = Collections.emptyList();
    private int absolutePositionRow;  // Absolute coordinate system
    private int previousWriteRow = absolutePositionRow;
    private boolean isVisible = true;

            return Collections.emptySet();
        }

        @Override
        public Set<String> getAccessibleDependentClasses() {
            return Collections.emptySet();
        }

        @Override
        public Set<String> getAllDependentClasses() {
            return Collections.emptySet();
        }

        @Override