this
    }

    String getGeneratorCode() {
        """
for (Element element : elements) {
    TypeElement typeElement = (TypeElement) element;
    String className = typeElement.getSimpleName().toString() + "Thing";
    try {
        JavaFileObject sourceFile = filer.createSourceFile(className${providesNoOriginatingElements ? "" : ", element"});
        Writer writer = sourceFile.openWriter();
        try {

        }
    }

    @Override
    public void add(int index, T element) {
        Objects.requireNonNull(element);
        if (setter != null) {
            List<U> list = new ArrayList<>(getter.get());
            list.add(index, revMapper.apply(element));
            setter.accept(list);
        } else {
            getter.get().add(index, revMapper.apply(element));
        }
    }

                for (Plugin element : src) {
                    Object key = getPluginKey().apply(element);
                    managedPlugins.put(key, element);
                }

                List<Plugin> newPlugins = new ArrayList<>();
                for (Plugin element : target.getPlugins()) {
                    Object key = getPluginKey().apply(element);

        int result = 0;
        for (XCTestElement element : getTestSuites()) {
            result += element.getFailureCount();
        }
        return result;
    }

    @Override
    public int getPassCount() {
        int result = 0;
        for (XCTestElement element : getTestSuites()) {
            result += element.getPassCount();
        }
        return result;
    }

    @Override

  public void testHashCode_containingNull() {
    Collection<E> elements = getSampleElements(getNumElements() - 1);
    int expectedHashCode = 0;
    for (E element : elements) {
      expectedHashCode += ((element == null) ? 0 : element.hashCode());
    }

    elements.add(null);
    collection = getSubjectGenerator().create(elements.toArray());
    assertEquals(

  // This reference is used both by the custom field serializer, and by the
  // GWT compiler to infer the elements of the lists that needs to be
  // serialized.
  E element;

  SingletonImmutableList(E element) {
    this.delegate = singletonList(checkNotNull(element));
    this.element = element;
  }

  @Override
  List<E> delegateList() {
    return delegate;
  }

  @Override
  void setCountCheckReturnValue(E element, int count) {
    assertEquals(
        "multiset.setCount() should return the old count",
        getMultiset().count(element),
        setCount(element, count));
  }

  @Override
  void setCountNoCheckReturnValue(E element, int count) {
    setCount(element, count);
  }

  @CanIgnoreReturnValue
  private int setCount(E element, int count) {

    private final Map<K, Collection<? extends T>> elements = new HashMap<>();
    private final Multimap<K, K> targetToSource = LinkedHashMultimap.create();

    /**
     * Adds new element and returns a conflict instance if given element is conflicted. Element is conflicted when:
     *  - has more than 1 candidate
     *  - is in conflict with an existing element (via replacedBy relationship)
     *

  final transient E element;

  SingletonImmutableSet(E element) {
    this.element = Preconditions.checkNotNull(element);
  }

  @Override
  public int size() {
    return 1;
  }

  @Override
  public boolean contains(@CheckForNull Object target) {
    return element.equals(target);
  }

  @Override
  public UnmodifiableIterator<E> iterator() {

// insertAfterFunc find and insert an element after the found element.
// If the f function returns true, the returned value will be inserted after the found element.
func insertAfterFunc[E any](s []E, f func(e E) (bool, E)) ([]E, bool) {
	var toInsert E
	idx := -1
	for k, v := range s {
		if ok, r := f(v); ok {
			toInsert = r
			idx = k
			break
		}
	}

	if idx == -1 {
		return s, false
	}