//
// {
//   {matcher {function_name {regex: "composite_conv.*"}}}
//   {method {static_range_ptq
//     {input_quantized_types {
//       key: 1,
//       value {dimension_specs {dimension: 3}}}}
//   }}
// }
QuantizationSpec GetPtqSpecForConvolution(Method::MethodCase method_case) {
  QuantizationSpec spec{};
  if (method_case != Method::kStaticRangePtq) {
    return spec;
  }

import org.gradle.internal.serialize.graph.writeClassArray
import java.lang.reflect.Method


object MethodCodec : Codec<Method> {

    override suspend fun WriteContext.encode(value: Method) {
        writeClass(value.declaringClass)
        writeString(value.name)
        writeClassArray(value.parameterTypes)
    }

    override suspend fun ReadContext.decode(): Method? {
        val declaringClass = readClass()

    }

    @Requires(
        value = IntegTestPreconditions.NotIsolatedProjects,
        reason = "Exercises IP incompatible behavior: Groovy method inheritance"
    )
    def "produces reasonable error message from a method inherited from a script containing only methods"() {
        createDirs("child")
        settingsFile << """
include 'child'
"""
        buildFile << """

    /**
     * Returns the unique name of this path type, including the module to patch if any.
     * For example, if this type is {@link JavaPathType#MODULES}, then this method returns {@code "MODULES"}.
     * But if this type was created by {@code JavaPathType.patchModule("foo.bar")}, then this method returns
     * {@code "PATCH_MODULE:foo.bar"}.
     *
     * @return the programmatic name together with the module name on which it applies

public interface ZipEntry {
    /**
     * The compression method used for an entry
     */
    enum ZipCompressionMethod {
        /**
         * The entry is compressed with DEFLATE algorithm.
         */
        DEFLATED,

        /**
         * The entry is stored uncompressed.
         */
        STORED,
        /**
         * The entry is compressed with some other method (Zip spec declares about a dozen of these).
         */

// as defaulting in the scheme is done as part of the conversion, and there would
// be no easy way to opt-out. Instead, if you want to use this defaulting method
// run it in your wrapper struct of this type in its `SetDefaults_` method.
func RecommendedDefaultPersistentVolumeBinderControllerConfiguration(obj *kubectrlmgrconfigv1alpha1.PersistentVolumeBinderControllerConfiguration) {
	zero := metav1.Duration{}

                    },
                    {
                        "type": "other.Type",
                        "member": "Method other.Type.someMethod",
                        "changes": ["Method has been removed"],
                        "acceptation": "I really want to do this"
                    }
                ]
            }
        """])

        then:

import com.google.errorprone.annotations.FormatMethod;
import com.google.errorprone.annotations.FormatString;

/**
 * Describes a method rule.
 * All implementations of this class are expected to implement the equals and hashCode method
 */
public interface ModelRuleDescriptor {
    /**
     * This method is expected to be idempotent.
     *
     * @param appendable where to write the description to.
     */

 * Otherwise, at least reduce <i>explicit</i> dependencies on this type by using lambda expressions
 * or method references instead of classes, leaving your code easier to migrate in the future.
 *
 * <p>To use an existing function (say, named {@code function}) in a context where the <i>other
 * type</i> of function is expected, use the method reference {@code function::apply}. A future

// Check Go language version-specific errors.

package p

// interface embedding

type I interface { m() }

type _ interface {
	m()
	I // ERROR "duplicate method m"
}

type _ interface {
	I
	I // ERROR "duplicate method m"