Object someMethodName(Object o)
    }

    interface ChildType extends BaseType {
        @Override String someMethodName(Object o)
        int someMethodName(int i)
    }

    def "distinguish overloaded overridden method signatures"() {
        def takeObjReturnObj = BaseType.declaredMethods[0]
        def takeObjReturnStr = ChildType.declaredMethods[0]
        def takeIntReturnInt = ChildType.declaredMethods[1]

        /*
         * This documents the current behavior, which is optimizing
         * for performance at the expense of not detecting some corner
         * cases. If there actually is a task that needs to distinguish
         * between links and real files, we should probably provide an
         * opt-in to canonical snapshotting, as it's quite expensive.
         */
        then:
        result.assertTaskSkipped(":work")

		}

		return 1
	}

	val := 0
	for i := 0; i < iter; i++ {
		m := m1
		if i%10 == 0 {
			m = m2
		}

		// N.B. Profiles only distinguish calls on a per-line level,
		// making the two calls ambiguous. However because the
		// interfaces and implementations are mutually exclusive,
		// devirtualization can still select the correct callee for
		// each.
		//

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.gradle.tooling.internal.protocol;

/**
 * A wrapper around a build failure, to distinguish it from an infrastructure failure. The details of the
 * failure are made available in the cause of this exception.
 *
 * DO NOT CHANGE THIS CLASS. It is part of the cross-version protocol.
 *
 * @since 1.0-milestone-3

// * golang/protobuf Message
// * gogo/protobuf Message
// * Able to marshal/unmarshal using json
type Spec any

func ToProto(s Spec) (*anypb.Any, error) {
	// golang protobuf. Use protoreflect.ProtoMessage to distinguish from gogo
	// golang/protobuf 1.4+ will have this interface. Older golang/protobuf are gogo compatible
	// but also not used by Istio at all.
	if pb, ok := s.(protoreflect.ProtoMessage); ok {

#define TENSORFLOW_COMPILER_MLIR_QUANTIZATION_STABLEHLO_CC_TYPES_H_

#include <string>

namespace mlir::quant::stablehlo {

// Introduces aliases for `std::string` to distinguish btw. function name and
// its alias, to prevent confusion when used together in a container. For
// example, it is easy to confuse function name -> alias mapping with alias ->

  // The number of successful finished jobs to retain.
  // This is a pointer to distinguish between explicit zero and not specified.
  // Defaults to 3.
  // +optional
  optional int32 successfulJobsHistoryLimit = 6;

  // The number of failed finished jobs to retain.
  // This is a pointer to distinguish between explicit zero and not specified.
  // Defaults to 1.
  // +optional

        allDependencies[0].resolved
        allDependencies[0].attemptedSelector == null
        allDependencies[1].resolved
        allDependencies[1].attemptedSelector == null
    }

    def "Client can distinguish resolved and unresolved dependencies"() {
        when:
        def project = loadToolingModel(EclipseProject)
        def allDependencies = project.classpath

  // The number of successful finished jobs to retain.
  // This is a pointer to distinguish between explicit zero and not specified.
  // Defaults to 3.
  // +optional
  optional int32 successfulJobsHistoryLimit = 6;

  // The number of failed finished jobs to retain.
  // This is a pointer to distinguish between explicit zero and not specified.
  // Defaults to 1.
  // +optional

        then:
        container.findByType(List) is extension
        container.findByType(new TypeOf<List<String>>() {}) is extension
    }

    def "can distinguish unrelated generic type arguments"() {
        given:
        def parents = []
        def capabilities = []

        when:
        container.add new TypeOf<List<Parent>>() {}, "parents", parents