}
	return &copy
}

// CAVEAT: the reason that `[2]criticalPath` can work is based on the implementation of current
// preemption algorithm, in particular the following 2 facts:
// Fact 1: we only preempt pods on the same node, instead of pods on multiple nodes.
// Fact 2: each node is evaluated on a separate copy of the preFilterState during its preemption cycle.

	runGo("tool", "pack", "c", "main.a", "main.o")

	// Add an extra section with a short, non-.o name.
	// This simulates an alternative build system.
	write(".facts", "this is not an object file")
	runGo("tool", "pack", "r", "main.a", ".facts")

	// Verify that the linker does not attempt
	// to compile the extra section.
	runGo("tool", "link", "-importcfg="+importcfgfile, "main.a")
}

			desc = "print"
		}
		pass.ReportRangef(call, "missing ... in args forwarded to %s-like function", desc)
		return
	}
	fn := w.obj
	var fact isWrapper
	if !pass.ImportObjectFact(fn, &fact) {
		fact.Kind = kind
		pass.ExportObjectFact(fn, &fact)
		res.funcs[fn] = kind
		for _, caller := range w.callers {
			checkPrintfFwd(pass, caller.w, caller.call, kind, res)
		}
	}
}

package main

import "fmt"

func fact[T interface{ ~int | ~int64 | ~float64 }](n T) T {
	if n == 1 {
		return 1
	}
	return n * fact(n-1)
}

func main() {
	const want = 120

	if got := fact(5); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	if got := fact[int64](5); got != want {
		panic(fmt.Sprintf("got %d, want %d", got, want))
	}

	// versus "vet fmt as a dependency of a non-std top-level vet".)
	// This is OK as long as the packages that are farther down the
	// dependency tree turn on *more* analysis, as here.
	// (The unsafeptr check does not write any facts for use by
	// later vet runs, nor does unreachable.)
	if a.Package.Goroot && !VetExplicit && VetTool == "" {
		// Turn off -unsafeptr checks.
		// There's too much unsafe.Pointer code

  // owns the underlying memory. This could be a .deepcopy()/clone() method.

  // TODO(bmzhao): In the future, we want to relax the non-copyability
  // constraint. To do so, we can add a C API function that acts like
  // CopyFrom:
  // https://github.com/tensorflow/tensorflow/blob/08931c1e3e9eb2e26230502d678408e66730826c/tensorflow/core/framework/tensor.h#L301-L311

  // Tensor is movable, but not copyable

     *
     * @param facets, a list of facets
     * @return the modified facet list
     */
    List<Facet> replaceInconsistentFacets(List<Facet> facets) {
        if (facets.stream().anyMatch(f -> "jst.ejb".equals(f.getName()))) {
            return facets.stream().filter(f -> !"jst.utility".equals(f.getName())).collect(Collectors.toList());
        }
        return facets;
    }

    }

    void assertHasFixedFacets(String... facets) {
        assert this.facets.fixed*.@facet == facets as List
    }

    void assertHasInstalledFacets(String... facets) {
        assert this.facets.installed*.@facet == facets as List
    }

    void assertFacetVersion(String facet, String version) {
        def facetNode = this.facets.installed.find { it.@facet == facet }
        assert facetNode != null

    private List<Facet> facets = new ArrayList<>(); // TODO: turn into Set?

    public WtpFacet(XmlTransformer xmlTransformer) {
        super(xmlTransformer);
    }

    public List<Facet> getFacets() {
        return facets;
    }

    public void setFacets(List<Facet> facets) {
        this.facets = facets;
    }

    @Override
    protected void load(Node xml) {

        classpath.lib('hamcrest-core-1.3.jar').assertIsExcludedFromDeployment()

        // Facets
        def facets = wtpFacets
        facets.assertHasFixedFacets("jst.java", "jst.web")
        facets.assertHasInstalledFacets("jst.web", "jst.java")
        facets.assertFacetVersion("jst.web", "2.4")
        facets.assertFacetVersion("jst.java", "6.0")

        // Component
        def component = wtpComponent