private static final int PUBLIC_STATIC_FINAL = Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL;
        private String className;
        /**
         * We only add getters for `public static final String` constants. This is because in
         * the converted classes only contain these kinds of constants.
         *

    return callee !is KtReferenceExpression ||
            analyze(callee) {
                isSimpleVariableAccessCall(callee)
            }
}

/**
 * The body of setters are always used. The body of getters are only used if they are expression bodies.
 */
private fun doesPropertyAccessorUseBody(propertyAccessor: KtPropertyAccessor, body: PsiElement): Boolean {

  bool enable_crash_reproducer;
};

// Return a pointer to the DumpGraphFlags struct;
// repeated calls return the same pointer.
// This should be called only after Flags::Parse() has returned.

// Getters for flags structs defined above.  The first call to any of these
// parses TF_XLA_FLAGS for all of them.  Those functions which return a pointer
// always return the same pointer.

      throw new UnsupportedOperationException();
    }
  }

  /*
   * TODO(cpovirk): surely we can find a less ugly solution than a class that accepts 3 parameters,
   * exposes as many getters, does work in the constructor, and has both a superclass and a subclass
   */
  public static class SortedMapSubmapTestMapGenerator<
          K extends @Nullable Object, V extends @Nullable Object>

      throw new UnsupportedOperationException();
    }
  }

  /*
   * TODO(cpovirk): surely we can find a less ugly solution than a class that accepts 3 parameters,
   * exposes as many getters, does work in the constructor, and has both a superclass and a subclass
   */
  public static class SortedMapSubmapTestMapGenerator<
          K extends @Nullable Object, V extends @Nullable Object>

        succeeds("build")
        file("build/libs/example.jar").exists()
    }

    def 'can configure an extension using DependencyCollector in declarative DSL that uses Kotlin properties for the getters'() {
        given: "a plugin that creates a custom extension using a DependencyCollector"
        file("build-logic/src/main/kotlin/com/example/restricted/DependenciesExtension.kt") << """

        abstract int getNumber()
        abstract void setNumber(int value)
    }

    def "rule class can have abstract getter and setter"() {
        expect:
        extract(AbstractPropertyRules).empty
    }

    def "can create instance of rule class with abstract getter and setter"() {
        when:
        def schema = extractor.extract(AbstractPropertyRules)
        def instance = schema.factory.create()

** For non-configurable properties, expose an link:{javadocPath}/org/gradle/api/provider/Provider.html[Provider] directly through a single getter.

2. Avoid simplifying calls like `obj.getProperty().get()` and `obj.getProperty().set(T)` in your code by introducing additional getters and setters.

3. When migrating your plugin to use providers, follow these guidelines:

		return true
	default:
		panic("bad type")
	}
}

// String returns the value v as a string.
// String is a special case because of Go's String method convention. Unlike the other getters,
// it does not panic if v's Type is not TypeString. Instead, it returns a string of the form "<T>"
// or "<T: V>" where T is v's type and V is a string representation of v's value.
func (v Value) String() string {

 * repository system instance(s) use {@link RepositorySystem#shutdown()} method on supplied instance(s).
 * <p>
 * Since Resolver 2.0 this class offers access to various components via public getters, and allows even partial object
 * graph construction.
 * <p>
 * Extend this class {@code createXXX()} methods and override to customize, if needed. The contract of this class makes