test your code with TF 1.1; ensure it raises no errors, and then upgrade to
    TF 1.2.
*   RNNCells' variable names have been renamed for consistency with Keras
    layers. Specifically, the previous variable names "weights" and "biases"
    have been changed to "kernel" and "bias", respectively. This may cause

 * to keep track of which items are filtered out of the source list.
 */
public class ImmutableFilteredList<T> extends AbstractList<T> {

    private final List<T> source;
    private final BitSet filter;

    private ImmutableFilteredList(List<T> source, BitSet filter) {
        this.source = source;
        this.filter = filter;
    }

    /**
     * Creates an {@code ImmutableFilteredList} which contains all the elements of {@code source}.

        }
        writeLn();
    }

    private void writeLibraries(DefaultVersionCatalog model) {
        List<String> aliases = model.getLibraryAliases();
        if (aliases.isEmpty()) {
            return;
        }
        writeTableHeader("libraries");
        for (String alias : aliases) {
            DependencyModel data = model.getDependencyData(alias);
            String group = data.getGroup();

import (
	"go/types"

	"golang.org/x/tools/internal/aliases"
)

// ReceiverNamed returns the named type (if any) associated with the
// type of recv, which may be of the form N or *N, or aliases thereof.
// It also reports whether a Pointer was present.
func ReceiverNamed(recv *types.Var) (isPtr bool, named *types.Named) {
	t := recv.Type()
	if ptr, ok := aliases.Unalias(t).(*types.Pointer); ok {
		isPtr = true
		t = ptr.Elem()

    }

    public static class KnownArchitecture {
        private final String canonicalName;
        private final List<String> aliases;

        public KnownArchitecture(String canonicalName, String... aliases) {
            this.canonicalName = canonicalName;
            this.aliases = Arrays.asList(aliases);
        }

        public String getCanonicalName() {
            return canonicalName;
        }

type Bundle struct {
	// Contain the local trust domain and its aliases.
	// The trust domain corresponds to the trust root of a system.
	// Refer to [SPIFFE-ID](https://github.com/spiffe/spiffe/blob/master/standards/SPIFFE-ID.md#21-trust-domain)
	// The trust domain aliases represent the aliases of `trust_domain`.
	// For example, if we have
	// trustDomain: td1, trustDomainAliases: ["td2", "td3"]

        withPlugins([(id): null])
    }

    void withPluginAlias(String alias) {
        withPlugins([:], [(alias): null])
    }

    void withPluginAliases(List<String> aliases = []) {
        withPlugins([:], aliases.collectEntries { [it, null] })
    }

    void withPluginsBlockContents(String block) {
        def text = buildFile.text
        int idx = text.indexOf('allprojects')

    /**
     * Return a sequence of [KaClassifierSymbol] which current scope contain if classifier name matches [nameFilter]. The sequence includes:
     * nested classes, inner classes, nested type aliases for the class scope, and top-level classes and top-level type aliases for file scope.
     *
     * This function needs to retrieve a set of all possible names before processing the scope.

import spock.lang.Specification


class ArchitecturesTest extends Specification {
    def "test 32-bit aliases"() {
        expect:
        Architectures.forInput(architecture).isI386()
        where:
        architecture << [ "x86", "i386", "ia-32", "i686" ]
    }

    def "test 64-bit aliases"() {
        expect:
        Architectures.forInput(architecture).isAmd64()
        where:

    /**
     * Declares a bundle of dependencies. A bundle consists of a name for the bundle,
     * and a list of aliases. The aliases must correspond to aliases defined via
     * the {@code library()} methods.
     *
     * @param alias the alias of the bundle
     * @param aliases the aliases of the dependencies included in the bundle
     * @see #library(String, String, String)
     * @see #library(String, String)
     */