SavedModelBundleLite& operator=(SavedModelBundleLite&& other) = default;

  SavedModelBundleLite(std::unique_ptr<Session> session,
                       protobuf::Map<string, SignatureDef> signatures)
      : session_(std::move(session)), signatures_(std::move(signatures)) {}

  /// A TensorFlow Session does not Close itself on destruction. To avoid
  /// resource leaks, we explicitly call Close on Sessions that we create.

import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeToken
import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
import org.jetbrains.kotlin.analysis.api.signatures.KaFunctionLikeSignature
import org.jetbrains.kotlin.analysis.api.signatures.KaVariableLikeSignature
import org.jetbrains.kotlin.analysis.api.symbols.KaValueParameterSymbol
import org.jetbrains.kotlin.analysis.api.symbols.KaFunctionLikeSymbol

			utilruntime.HandleError(err)
		}

		// Check to see if this signature is changed or new.
		oldSig, _ := sigs[tokenID]
		if sig != oldSig {
			needUpdate = true
		}
		delete(sigs, tokenID)

		newCM.Data[bootstrapapi.JWSSignatureKeyPrefix+tokenID] = sig
	}

	// If we have signatures left over we know that some signatures were
	// removed.  We now need to update the ConfigMap
	if len(sigs) != 0 {

 * different signatures.
 */
@GwtCompatible(emulated = true)
@J2ktIncompatible // Super-sourced
@ElementTypesAreNonnullByDefault
abstract class GwtFuturesCatchingSpecialization {
  /*
   * This server copy of the class is empty. The corresponding GWT copy contains alternative
   * versions of catching() and catchingAsync() with slightly different signatures from the ones
   * found in Futures.java.
   */

 * versions of the {@link FluentFuture#catching(Class, com.google.common.base.Function)
 * FluentFuture.catching} family of methods. Those versions have slightly different signatures.
 */
@GwtCompatible(emulated = true)
@J2ktIncompatible // Super-sourced
@ElementTypesAreNonnullByDefault
abstract class GwtFluentFutureCatchingSpecialization<V extends @Nullable Object>
    extends AbstractFuture<V> {

This can indicate that a dependency has been compromised. Please carefully verify the signatures and checksums."""

        def artifactFile = getCachedArtifactLocation(module, 'jar.asc')
        outputContains("Expected a signature list in ${artifactFile}, but got invalid file. Skipping this signature.")
        assertConfigCacheDiscarded()
    }

    private static void tamperWithFile(File file) {

 */

package org.jetbrains.kotlin.analysis.api.descriptors.signatures

import org.jetbrains.kotlin.analysis.api.lifetime.KaLifetimeToken
import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
import org.jetbrains.kotlin.analysis.api.signatures.KaVariableLikeSignature
import org.jetbrains.kotlin.analysis.api.symbols.KaVariableLikeSymbol

func (s *Signature) TypeParams() *TypeParamList { return s.tparams }

// RecvTypeParams returns the receiver type parameters of signature s, or nil.
func (s *Signature) RecvTypeParams() *TypeParamList { return s.rparams }

// Params returns the parameters of signature s, or nil.
func (s *Signature) Params() *Tuple { return s.params }

// Results returns the results of signature s, or nil.

}

type T2 interface {
	m() interface{T2}
}

func _(x T1, y T2) {
	// Checking for assignability of interfaces must check
	// if all methods of x are present in y, and that they
	// have identical signatures. The signatures recur via
	// the result type, which is an interface that embeds
	// a single method m that refers to the very interface
	// that contains it. This requires cycle detection in
	// identity checks for interface types.

    const SavedModelBundle& saved_model_bundle) {
  // Translate protobuf::Map -> absl::flat_hash_map.
  const protobuf::Map<std::string, SignatureDef>& signatures =
      saved_model_bundle.GetSignatures();
  absl::flat_hash_map<std::string, SignatureDef> signature_def_map(
      signatures.begin(), signatures.end());

  // Init op is only used during initialization and it's not a target for
  // quantization.