enum class Enum(val i: Int) {

    TEST(45),
    PROBE(45),
    SONDE(45);

    constructor(<expr>x: String</expr>) : this(x.length) {
    }

enum class Enum(val i: Int) {

    TEST(45),
    PROBE(45),
    SONDE(45);

    constructor(x: String) : <expr>this</expr>(x.length)

    runTest("analysis/analysis-api/testData/components/typeProvider/haveCommonSubtype/dataClasses.kt");
  }

  @Test
  @TestMetadata("enums.kt")
  public void testEnums() {
    runTest("analysis/analysis-api/testData/components/typeProvider/haveCommonSubtype/enums.kt");
  }

  @Test
  @TestMetadata("simple.kt")
  public void testSimple() {

import com.google.common.base.Joiner;

import java.util.Locale;

class Names {
    static String displayNameFor(Enum<?> value) {
        String[] parts = value.name().toLowerCase(Locale.US).split("_");
        return Joiner.on(' ').join(parts);
    }

    static String idFor(Enum<?> value) {
        String[] parts = value.name().toLowerCase(Locale.US).split("_");
        return Joiner.on('-').join(parts);
    }

 */
@GwtCompatible(serializable = true, emulated = true)
@SuppressWarnings("serial") // we're overriding default serialization
@ElementTypesAreNonnullByDefault
final class ImmutableEnumSet<E extends Enum<E>> extends ImmutableSet<E> {
  static <E extends Enum<E>> ImmutableSet<E> asImmutable(EnumSet<E> set) {
    switch (set.size()) {
      case 0:
        return ImmutableSet.of();
      case 1:

package org.gradle.test

import org.gradle.test.sub2.GroovyInterface

class GroovyClassWithInnerTypes implements GroovyInterface {
    /**
     * This is an inner enum.
     */
    enum InnerEnum {}

    /**
     * This is an inner class.
     */
    static class InnerClass {
        InnerEnum enumProp

        /**
         * This is an inner inner class.
         */
        class AnotherInner {

// MODULE: lib1
// FILE: anno.kt
package kotlin.annotation

public enum class AnnotationTarget {
    CLASS;
}

// MODULE: dep(lib1)
// FILE: annotation.kt
package my.pack

import kotlin.annotation.AnnotationTarget

@Target(AnnotationTarget.CLASS)
annotation class Deprecated

// MODULE: lib2
// FILE: anno.kt
package kotlin.annotation

public enum class AnnotationTarget {
    CLASS;
}

import java.util.EnumSet;

/**
 * Request for interceptors. Currently, we support filter just for interception types, but in the feature we could also filter per version etc.
 *
 * Implemented as a enum, so it's easier to generate bytecode.
 */
public enum BytecodeInterceptorFilter {
    INSTRUMENTATION_ONLY(EnumSet.of(BytecodeInterceptorType.INSTRUMENTATION)),

    void doSomething() {
    }

    @Option(option = "enumValue", description = "Configures an enum value in CustomTask.")
    public void setEnumValue(TestEnum value) {
    }

    @Option(option = "booleanValue", description = "Configures a boolean flag in CustomTask.")
    public void setBooleanValue(boolean value) {
    }
}

enum TestEnum {
    ABC, DEF, GHIJKL

            private fun c() {}

        }
    }
}

interface D {
    private fun d() {}
    inner class E {
        private fun e() {}
        enum class F {
            private fun f() {}
        }
    }
}

enum class G {
    H, I;

    private fun g() {}
}


fun foo() {
    private fun fooA() {}

    class FooI {
        private fun m() {}
    }