public object KaDeclarationModifiersRendererForSource {
    public val NO_IMPLICIT_MODIFIERS: KaDeclarationModifiersRenderer = KaDeclarationModifiersRenderer {
        modifierListRenderer = KaModifierListRenderer.AS_LIST
        modifiersSorter = KaModifiersSorter.CANONICAL
        modalityProvider = KaRendererModalityModifierProvider.WITHOUT_IMPLICIT_MODALITY
        visibilityProvider = KaRendererVisibilityModifierProvider.NO_IMPLICIT_VISIBILITY

    public fun renderSuperTypes(
        analysisSession: KaSession,
        symbol: KaClassOrObjectSymbol,
        declarationRenderer: KaDeclarationRenderer,
        printer: PrettyPrinter,
    )

    public object AS_LIST : KaSuperTypeListRenderer {
        override fun renderSuperTypes(
            analysisSession: KaSession,
            symbol: KaClassOrObjectSymbol,
            declarationRenderer: KaDeclarationRenderer,

        analysisSession: KaSession,
        symbol: KaDeclarationSymbol,
        declarationModifiersRenderer: KaDeclarationModifiersRenderer,
        printer: PrettyPrinter,
    )

    public object AS_LIST : KaModifierListRenderer {
        override fun renderModifiers(
            analysisSession: KaSession,
            symbol: KaDeclarationSymbol,
            declarationModifiersRenderer: KaDeclarationModifiersRenderer,

        bodyMemberScopeSorter = KaRendererBodyMemberScopeSorter.ENUM_ENTRIES_AT_BEGINING

        superTypeRenderer = KaSuperTypeRenderer.WITH_OUT_APPROXIMATION
        superTypeListRenderer = KaSuperTypeListRenderer.AS_LIST
        superTypesFilter = KaSuperTypesFilter.NO_DEFAULT_TYPES
        superTypesArgumentRenderer = KaSuperTypesCallArgumentsRenderer.EMPTY_PARENS
        functionLikeBodyRenderer = KaFunctionLikeBodyRenderer.NO_BODY

            copy.call();
        } else {
            Object[] argList = new Object[inputs.size() + 1];
            argList[0] = subject;
            int i = 1;
            for (Object arg : inputs) {
                argList[i++] = arg;
            }
            copy.call(argList);
        }
    }

    private List<Class<?>> parseInputTypes(Closure<?> closure) {

        projectParent.setCollectedProjects(asList(
                projectIndependentModule,
                projectModuleA,
                projectModuleB,
                projectModuleC,
                projectModuleC1,
                projectModuleC2));
        projectModuleC.setCollectedProjects(asList(projectModuleC1, projectModuleC2));

        // Set up needed mocks

			// non-generic signature.
			targs = nil
			xlist = nil
		}
	}

	// evaluate arguments
	args, atargs, atxlist := check.genericExprList(call.ArgList)
	sig = check.arguments(call, sig, targs, xlist, args, atargs, atxlist)

	if wasGeneric && sig.TypeParams().Len() == 0 {
		// update the recorded type of call.Fun to its instantiated type

    List<String> b = asList("c", "d");
    ImmutableSortedMultiset<String> multiset =
        ImmutableSortedMultiset.<String>naturalOrder().addAll(a).addAll(b).build();
    assertEquals(HashMultiset.create(asList("a", "b", "c", "d")), multiset);
  }

  public void testBuilderAddAllMultiset() {
    Multiset<String> a = HashMultiset.create(asList("a", "b", "b"));

                Contributor.newBuilder().email("******@****.***").build();

        Model target =
                Model.newBuilder().contributors(Arrays.asList(contributor)).build();

        Model source =
                Model.newBuilder().contributors(Arrays.asList(contributor)).build();

        Model merged = mavenMerger.merge(target, source, true, null);

        assertThat(merged.getContributors(), contains(contributor));

    Multiset<String> ms2 = HashMultiset.create(Arrays.asList("a"));
    assertThat(Multisets.difference(ms1, ms2)).containsExactly("a", "b");
  }

  public void testDifferenceWithRemovedElement() {
    Multiset<String> ms1 = HashMultiset.create(Arrays.asList("a", "b", "a"));
    Multiset<String> ms2 = HashMultiset.create(Arrays.asList("b"));