<nature>org.eclipse.wst.common.project.facet.core.nature</nature>
		<nature>org.eclipse.wst.common.modulecore.ModuleCoreNature</nature>
		<nature>org.eclipse.jem.workbench.JavaEMFNature</nature>
	</natures>
	<buildSpec>
		<buildCommand>
			<name>org.eclipse.jdt.core.javabuilder</name>
			<arguments/>
		</buildCommand>
		<buildCommand>
			<name>org.eclipse.wst.common.project.facet.core.builder</name>
			<arguments/>

        }
        return facet;
    }

    public void setFacet(EclipseWtpFacet facet) {
        this.facet = facet;
    }

    /**
     * Configures wtp facet.
     * <p>
     * For examples see docs for {@link EclipseWtpFacet}
     */
    public void facet(@DelegatesTo(EclipseWtpFacet.class) Closure action) {
        configure(action, getFacet());
    }

    /**

                    @Override
                    public List<Facet> call() throws Exception {
                        return Lists.newArrayList(
                            new Facet(Facet.FacetType.fixed, "jst.java", null),
                            new Facet(Facet.FacetType.installed, "jst.utility", "1.0"),

        removeConfigurableDataFromXml();
        for (Facet facet : facets) {
            facet.appendNode(xml);
        }
    }

    @Override
    protected String getDefaultResourceName() {
        return "defaultWtpFacet.xml";
    }

    public void configure(List<Facet> facets) {
        this.facets.addAll(facets);
        removeDuplicates();
    }

    private void removeDuplicates() {

<faceted-project>
	<fixed facet="jst.java"/>
	<installed facet="jst.java" version="5.0"/>
	<installed facet="jst.utility" version="1.0"/>

        model.wtp.facet == facet
        model.wtp.facet.facets.empty

        when: "configure wtp component and facet"
        model.wtp.component({ comp -> comp.deployName = 'name' } as Action<EclipseWtpComponent>)
        model.wtp.facet({ fac -> fac.facets.add(new Facet()) } as Action<EclipseWtpFacet>)

        then:
        model.wtp.component.deployName == 'name'
        model.wtp.facet.facets.size() == 1

<faceted-project>
	<fixed facet="jst.java"/>
	<fixed facet="jst.web"/>
	<installed facet="jst.web" version="2.4"/>
	<installed facet="jst.java" version="6.0"/>

eclipse.project.file.beforeMerged { project ->
    project.natures.clear()
}
// end::project-before-merged[]

// tag::wtp-with-xml[]
eclipse.wtp.facet.file.withXml { provider ->
    provider.asNode().fixed.find { it.@facet == 'jst.java' }.@facet = 'jst2.java'
}
// end::wtp-with-xml[]

sourceSets {
    integTest
}

configurations {
    functional
}

eclipse {
    classpath {

-- go.mod --
module m

go 1.20
-- main.go --
package main

import "m/sub"

func main() { sub.F() }
-- sub/sub.go --
package sub

type iface interface{ m() }

func F() {
	f := func(rt []iface) []iface {
		return append([]iface{}, rt...)
	}
	f(nil)

func (t *TypeParam) Underlying() Type {
	return t.iface()
}

func (t *TypeParam) String() string { return TypeString(t, nil) }

// ----------------------------------------------------------------------------
// Implementation

func (t *TypeParam) cleanup() {
	t.iface()
	t.check = nil
}

// iface returns the constraint interface of t.
func (t *TypeParam) iface() *Interface {
	bound := t.bound