py_function_lib_;

  // Path to the pre-calibrated SavedModel.
  std::string src_saved_model_path_;

  // Function alias mapping for pre-calibrated SavedModel. Used to preserve
  // aliased functions.
  absl::flat_hash_map<FunctionName, FunctionAlias> function_aliases_;

  // Tags to identify the MetaGraphDef to load from a SavedModel.

// hashFor computes the hash of t.
func (h Hasher) hashFor(t types.Type) uint32 {
	// See Identical for rationale.
	switch t := t.(type) {
	case *types.Basic:
		return uint32(t.Kind())

	case *aliases.Alias:
		return h.Hash(aliases.Unalias(t))

	case *types.Array:
		return 9043 + 2*uint32(t.Len()) + 3*h.Hash(t.Elem())

	case *types.Slice:
		return 9049 + 2*h.Hash(t.Elem())

	case *types.Struct:

			want:  []string{"single-policy-out.yaml"},
		},
		{
			name:     "trust-domain-one-alias",
			tdBundle: trustdomain.NewBundle("td1", []string{"cluster.local"}),
			input:    "simple-policy-td-aliases-in.yaml",
			want:     []string{"simple-policy-td-aliases-out.yaml"},
		},
		{
			name:     "trust-domain-multiple-aliases",
			tdBundle: trustdomain.NewBundle("td1", []string{"cluster.local", "some-td"}),

// are stored. This value will be fed to the "file_prefix" tensor to restore the
// variables.
// * `function_aliases` maps the actual function name to the function alias.
// This associates the quantized functions to the original functions' aliases.
// If there were no function aliases in the input model, this should be empty.
// * `asset_file_defs` include information about the assets, if any, that are

The methods [Alias.Origin], [Alias.SetTypeParams], [Alias.TypeParams],

        ":signature_def_param_list",
        ":tensor_spec",
    ],
)

alias(
    name = "concrete_function",
    actual = "//tensorflow/c/experimental/saved_model/internal:concrete_function",
)

alias(
    name = "concrete_function_list",
    actual = "//tensorflow/c/experimental/saved_model/internal:concrete_function_list",
)

alias(
    name = "function_metadata",

def _save_function_alias(
    saved_model_dir: str,
    tags: Collection[str],
    function_aliases: Mapping[str, str],
) -> None:
  """Saves the function alias to the SavedModel.

  SavedModelBuilder (TF1 saved model saver) does not support saving function
  aliases, so this function loads the SavedModel proto and adds the
  `function_aliases` field.

  Args:
    saved_model_dir: Path to the saved model directory.

				oldidx := uint32(pass.ID)
				po.constants[val] = oldidx
			}

		case undoAliasNode:
			ID, prev := pass.ID, pass.idx
			cur := po.values[ID]
			if prev == 0 {
				// Born as an alias, die as an alias
				delete(po.values, ID)
			} else {
				if cur == prev {
					panic("invalid aliasnode undo pass")
				}
				// Give it back previous value
				po.values[ID] = prev
			}

	}
	return end
}

func ZeroValue(f *ast.File, pkg *types.Package, typ types.Type) ast.Expr {
	// TODO(adonovan): think about generics, and also generic aliases.
	under := aliases.Unalias(typ)
	// Don't call Underlying unconditionally: although it removes
	// Named and Alias, it also removes TypeParam.
	if n, ok := under.(*types.Named); ok {
		under = n.Underlying()
	}
	switch under := under.(type) {
	case *types.Basic:

    versionCatalogs {
        libs {
            plugin('$alias', 'com.acme.greeter').version('1.5')
        }
    }
}"""
        withPluginAlias "libs.plugins.${alias.replace('-', '.')}"

        when:
        plugin.allowAll()
        succeeds taskName

        then:
        outputContains message

        where:
        alias << ['greeter', 'some.greeter', 'some-greeter']
    }