String extension = avs.getExtension() != null ? avs.getExtension() : avs.getType();
        return new DefaultIvyArtifactName(
            nameOf(target),
            avs.getType(),
            extension,
            avs.getClassifier()
        );
    }

    private static String nameOf(ComponentSelector target) {
        if (target instanceof ModuleComponentSelector) {

	}

	AssertEqual(t, r.Statement.Vars, []interface{}{2, 4, 1, 3})
}

type UserWithTableNamer struct {
	gorm.Model
	Name string
}

func (UserWithTableNamer) TableName(namer schema.Namer) string {
	return namer.TableName("user")
}

func TestTableWithNamer(t *testing.T) {
	db, _ := gorm.Open(tests.DummyDialector{}, &gorm.Config{
		NamingStrategy: schema.NamingStrategy{
			TablePrefix: "t_",
		},

    Location loc = tensorflow::GetLocationWithoutOpType(op->getLoc());
    if (auto name = loc.dyn_cast<NameLoc>()) {
      return name.getName().strref();
    } else if (auto fused_name = loc.dyn_cast<FusedLoc>()) {
      for (auto sub_loc : fused_name.getLocations()) {
        if (auto named_sub_loc = sub_loc.dyn_cast<NameLoc>()) {
          return named_sub_loc.getName().strref();
        }
      }
    }

 */

package org.gradle.jvm.toolchain.internal;

import org.gradle.api.Action;
import org.gradle.api.GradleException;
import org.gradle.api.InvalidUserCodeException;
import org.gradle.api.Namer;
import org.gradle.api.artifacts.repositories.AuthenticationContainer;
import org.gradle.api.artifacts.repositories.PasswordCredentials;
import org.gradle.api.credentials.Credentials;

    /**
     * An implementation of the namer interface for configurations that returns {@link #getName()}.
     *
     * @deprecated Use {@link Named.Namer#INSTANCE} instead (since {@link Configuration} now extends {@link Named}).
     */
    @Deprecated
    class Namer implements org.gradle.api.Namer<Configuration> {

        public Namer() {
            DeprecationLogger.deprecateType(Namer.class)

import org.gradle.api.DomainObjectCollection
import org.gradle.api.NamedDomainObjectCollection
import org.gradle.api.NamedDomainObjectCollectionSchema
import org.gradle.api.NamedDomainObjectProvider
import org.gradle.api.Namer
import org.gradle.api.Rule
import org.gradle.api.UnknownDomainObjectException
import org.gradle.api.provider.Provider
import org.gradle.api.specs.Spec
import org.gradle.util.TestUtil
import spock.lang.Specification

    override fun <S : Task> named(name: String, type: Class<S>, configurationAction: Action<in S>): TaskProvider<S> =
        delegate.named(name, type, configurationAction)

    override fun getNamer(): Namer<Task> =
        delegate.namer

    override fun getRules(): MutableList<Rule> =
        delegate.rules

    override fun getCollectionSchema(): NamedDomainObjectCollectionSchema =
        delegate.collectionSchema

    public DefaultTaskCollection(Class<T> type, Instantiator instantiator, ProjectInternal project, MutationGuard parentMutationGuard, CollectionCallbackActionDecorator decorator) {
        super(type, instantiator, Named.Namer.INSTANCE, decorator);
        this.project = project;
        this.parentMutationGuard = parentMutationGuard;
    }

	return *s.WithDescription(desc)
}

func generateBuildDefinitionsFunc() {
	namer = openapi.NewDefinitionNamer(scheme.Scheme)
	definitionsV3 = utilopenapi.GetOpenAPIDefinitionsWithoutDisabledFeatures(generatedopenapi.GetOpenAPIDefinitions)(func(name string) spec.Ref {
		defName, _ := namer.GetDefinitionName(name)
		prefix := v3DefinitionPrefix
		return spec.MustCreateRef(prefix + common.EscapeJsonPointer(defName))

      RankedTensorType::get(/*shape=*/{}, builder.getType<TF::StringType>());
  BlockArgument new_file_prefix_arg =
      main_func_op.getBody().front().addArgument(
          file_prefix_arg_type,
          NameLoc::get(builder.getStringAttr(kTfFilePrefix)));

  SmallVector<Type> input_types(main_func_op.getArgumentTypes());
  input_types.emplace_back(file_prefix_arg_type);

  main_func_op.setType(