goscript 0.1.0 → 0.1.2

package/compiler/override-registry_test.go

@@ -35,6 +35,53 @@ func TestOverrideRegistryPlansRuntimeAndOverrideDependencies(t *testing.T) {
 	}
 }
 
+func TestOverrideRegistryFactsAreImmutable(t *testing.T) {
+	owner := NewOverrideRegistryOwner()
+	facts, diagnostics := owner.Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("override facts failed: %#v", diagnostics)
+	}
+
+	metadata := facts.Metadata("sync")
+	if !metadata.AsyncMethods["Map.Load"] {
+		t.Fatalf("expected sync Map.Load async metadata")
+	}
+	metadata.AsyncMethods["Map.Load"] = false
+	metadata.Dependencies = append(metadata.Dependencies, "mutated")
+
+	metadata = facts.Metadata("sync")
+	if !metadata.AsyncMethods["Map.Load"] {
+		t.Fatalf("override metadata mutation leaked back into facts")
+	}
+	if slices.Contains(metadata.Dependencies, "mutated") {
+		t.Fatalf("override dependency mutation leaked back into facts: %v", metadata.Dependencies)
+	}
+
+	pkg, dependencies, ok := facts.copyPackage("fmt")
+	if !ok {
+		t.Fatalf("missing fmt copy package facts")
+	}
+	if !slices.Contains(dependencies, "errors") {
+		t.Fatalf("expected fmt dependency on errors, got %v", dependencies)
+	}
+	dependencies = append(dependencies, "mutated")
+	if len(pkg.files) == 0 {
+		t.Fatalf("expected fmt copy files")
+	}
+	pkg.files[0].data[0] = '!'
+
+	pkg, dependencies, ok = facts.copyPackage("fmt")
+	if !ok {
+		t.Fatalf("missing fmt copy package facts after mutation")
+	}
+	if slices.Contains(dependencies, "mutated") {
+		t.Fatalf("copy dependency mutation leaked back into facts: %v", dependencies)
+	}
+	if len(pkg.files) == 0 || pkg.files[0].data[0] == '!' {
+		t.Fatalf("copy file mutation leaked back into facts")
+	}
+}
+
 func TestOverrideRegistryCopiesRuntimeAndOverrides(t *testing.T) {
 	owner := NewOverrideRegistryOwner()
 	req := &CompileRequest{
@@ -71,6 +118,47 @@ func TestOverrideRegistryCopiesRuntimeAndOverrides(t *testing.T) {
 	}
 }
 
+func TestOverrideRegistryCopiesExternalOverride(t *testing.T) {
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/lib/index.ts", strings.Join([]string{
+		"import * as helper from '@goscript/example.test/helper/index.js'",
+		"export function Run(): void { helper.Run() }",
+		"",
+	}, "\n"))
+	writeFixtureFile(t, overrideDir, "example.test/lib/meta.json", `{"dependencies":["example.test/helper"]}`)
+	writeFixtureFile(t, overrideDir, "example.test/helper/index.ts", "export function Run(): void {}\n")
+
+	owner := NewOverrideRegistryOwner(overrideDir)
+	req := &CompileRequest{
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	}
+	plan, diagnostics := owner.CopyPlan(context.Background(), req, &PackageGraph{Nodes: []*PackageGraphNode{{
+		PkgPath:           "example.test/lib",
+		OverrideCandidate: true,
+	}}})
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("copy plan failed: %#v", diagnostics)
+	}
+	copied, diagnostics := owner.CopyPackages(context.Background(), req, plan)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("copy failed: %#v", diagnostics)
+	}
+	for _, pkg := range []string{"builtin", "example.test/helper", "example.test/lib"} {
+		if !slices.Contains(copied, pkg) {
+			t.Fatalf("missing copied package %s in %v", pkg, copied)
+		}
+	}
+	for _, path := range []string{
+		"@goscript/example.test/helper/index.ts",
+		"@goscript/example.test/lib/index.ts",
+	} {
+		if _, err := os.Stat(filepath.Join(req.OutputPath, filepath.FromSlash(path))); err != nil {
+			t.Fatalf("expected copied file %s: %v", path, err)
+		}
+	}
+}
+
 func TestOverrideRegistryReportsMissingOverridePackage(t *testing.T) {
 	_, diagnostics := NewOverrideRegistryOwner().CopyPlan(context.Background(), &CompileRequest{
 		RuntimeEmissionMode: RuntimeEmissionModeEmit,
@@ -205,3 +293,97 @@ func TestCompilePackagesAwaitsOverrideAsyncMethods(t *testing.T) {
 		t.Fatalf("override async method call was not awaited:\n%s", string(content))
 	}
 }
+
+func TestCompilePackagesPropagatesOverrideAsyncInterfaceMethods(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/overrideasynciface\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import \"net/http\"",
+			"type client struct { rt http.RoundTripper }",
+			"func (c *client) Do(req *http.Request) (*http.Response, error) {",
+			"  return c.rt.RoundTrip(req)",
+			"}",
+			"func Use(c *client, req *http.Request) (*http.Response, error) {",
+			"  return c.Do(req)",
+			"}",
+			"func main() {}",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "overrideasynciface", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	text := string(content)
+	for _, want := range []string{
+		"public async Do(req: http.Request | $.VarRef<http.Request> | null): globalThis.Promise<[http.Response | $.VarRef<http.Response> | null, $.GoError]>",
+		"return await $.pointerValue<Exclude<http.RoundTripper, null>>($.pointerValue<client>(c).rt).RoundTrip(req)",
+		"export async function Use(c: client | $.VarRef<client> | null, req: http.Request | $.VarRef<http.Request> | null): globalThis.Promise<[http.Response | $.VarRef<http.Response> | null, $.GoError]>",
+		"return await client.prototype.Do.call(c, req)",
+	} {
+		if !strings.Contains(text, want) {
+			t.Fatalf("missing %q in generated output:\n%s", want, text)
+		}
+	}
+}
+
+func TestCompilePackagesAwaitsOverrideAsyncFunctions(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": "module example.test/overrideasyncfunc\n\ngo 1.25.3\n",
+		"main.go": strings.Join([]string{
+			"package main",
+			"import (",
+			"  \"io/fs\"",
+			"  \"path/filepath\"",
+			"  \"sync\"",
+			")",
+			"func main() {",
+			"  var m sync.Map",
+			"  _ = filepath.WalkDir(\".\", func(path string, d fs.DirEntry, err error) error {",
+			"    if _, ok := m.Load(path); ok {",
+			"      return nil",
+			"    }",
+			"    return nil",
+			"  })",
+			"}",
+			"",
+		}, "\n"),
+	})
+	out := filepath.Join(t.TempDir(), "out")
+	comp, err := NewCompiler(&Config{
+		Dir:             moduleDir,
+		OutputPath:      out,
+		AllDependencies: true,
+	}, nil, nil)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+
+	if _, err := comp.CompilePackages(context.Background(), "."); err != nil {
+		t.Fatal(err.Error())
+	}
+	content, err := os.ReadFile(filepath.Join(out, "@goscript", "example.test", "overrideasyncfunc", "main.gs.ts"))
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	if !strings.Contains(string(content), "await filepath.WalkDir") {
+		t.Fatalf("override async function call was not awaited:\n%s", string(content))
+	}
+	if !strings.Contains(string(content), "$.functionValue(async") {
+		t.Fatalf("walk callback was not lowered as async:\n%s", string(content))
+	}
+}

package/compiler/package-graph.go

@@ -3,9 +3,9 @@ package compiler
 import (
 	"context"
 	"os"
-	"sort"
+	"slices"
+	"strings"
 
-	gs "github.com/aperturerobotics/goscript"
 	"golang.org/x/tools/go/packages"
 )
 
@@ -35,6 +35,8 @@ type PackageGraphNode struct {
 	ModulePath string
 	// ModuleDir is the owning module directory when known.
 	ModuleDir string
+	// ForTest is the package path under test for Go test variants.
+	ForTest string
 	// GoFiles are the package source files.
 	GoFiles []string
 	// CompiledGoFiles are files selected by build constraints.
@@ -48,11 +50,17 @@ type PackageGraphNode struct {
 }
 
 // PackageGraphOwner owns Go package loading and graph identity.
-type PackageGraphOwner struct{}
+type PackageGraphOwner struct {
+	overrideOwner *OverrideRegistryOwner
+}
 
 // NewPackageGraphOwner creates the package graph owner.
-func NewPackageGraphOwner() *PackageGraphOwner {
-	return &PackageGraphOwner{}
+func NewPackageGraphOwner(overrideOwners ...*OverrideRegistryOwner) *PackageGraphOwner {
+	overrideOwner := NewOverrideRegistryOwner()
+	if len(overrideOwners) != 0 && overrideOwners[0] != nil {
+		overrideOwner = overrideOwners[0]
+	}
+	return &PackageGraphOwner{overrideOwner: overrideOwner}
 }
 
 // Load builds the package graph for a validated request.
@@ -69,8 +77,8 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 		Context:    ctx,
 		Dir:        req.Dir,
 		Env:        append(os.Environ(), "GOOS=js", "GOARCH=wasm"),
-		BuildFlags: append([]string(nil), req.BuildFlags...),
-		Tests:      false,
+		BuildFlags: goScriptBuildFlags(req.BuildFlags),
+		Tests:      req.Tests,
 		Mode: packages.NeedName |
 			packages.NeedFiles |
 			packages.NeedCompiledGoFiles |
@@ -81,6 +89,7 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 			packages.NeedSyntax |
 			packages.NeedTypesInfo |
 			packages.NeedTypesSizes |
+			packages.NeedForTest |
 			packages.NeedModule,
 	}
 	pkgs, err := packages.Load(cfg, req.Patterns...)
@@ -99,6 +108,10 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 			Message:  "package patterns did not match any packages",
 		}}
 	}
+	overrideFacts, overrideDiagnostics := o.overrideOwner.Facts(ctx)
+	if diagnosticsHaveErrors(overrideDiagnostics) {
+		return nil, overrideDiagnostics
+	}
 
 	graph := &PackageGraph{
 		RequestedPatterns:     append([]string(nil), req.Patterns...),
@@ -109,23 +122,29 @@ func (o *PackageGraphOwner) Load(ctx context.Context, req *CompileRequest) (*Pac
 
 	requested := make(map[string]bool)
 	for _, pkg := range pkgs {
+		if isTestMainPackage(pkg) {
+			continue
+		}
 		path := packagePath(pkg)
 		requested[path] = true
 		graph.RequestedPackagePaths = append(graph.RequestedPackagePaths, path)
 	}
-	sort.Strings(graph.RequestedPackagePaths)
+	slices.Sort(graph.RequestedPackagePaths)
 
 	var diagnostics []Diagnostic
 	seen := make(map[string]bool)
 	for _, pkg := range pkgs {
-		o.collect(graph, pkg, req.DependencyMode, requested, seen)
+		if isTestMainPackage(pkg) {
+			continue
+		}
+		o.collect(graph, pkg, req.DependencyMode, requested, overrideFacts, seen)
 		diagnostics = append(diagnostics, packageDiagnostics(pkg)...)
 	}
-	sort.Slice(graph.Nodes, func(i, j int) bool {
-		if graph.Nodes[i].PkgPath == graph.Nodes[j].PkgPath {
-			return graph.Nodes[i].ID < graph.Nodes[j].ID
+	slices.SortFunc(graph.Nodes, func(a, b *PackageGraphNode) int {
+		if a.PkgPath == b.PkgPath {
+			return strings.Compare(a.ID, b.ID)
 		}
-		return graph.Nodes[i].PkgPath < graph.Nodes[j].PkgPath
+		return strings.Compare(a.PkgPath, b.PkgPath)
 	})
 	if len(graph.Nodes) == 0 {
 		diagnostics = append(diagnostics, Diagnostic{
@@ -142,15 +161,22 @@ func (o *PackageGraphOwner) collect(
 	pkg *packages.Package,
 	mode DependencyMode,
 	requested map[string]bool,
+	overrideFacts *OverrideFacts,
 	seen map[string]bool,
 ) {
 	if pkg == nil || seen[pkg.ID] {
 		return
 	}
+	if pkg.ForTest != "" && !requested[pkg.ForTest] {
+		if prod := pkg.Imports[pkg.ForTest]; prod != nil {
+			o.collect(graph, prod, mode, requested, overrideFacts, seen)
+		}
+		return
+	}
 	seen[pkg.ID] = true
 
 	path := packagePath(pkg)
-	node := newPackageGraphNode(pkg, requested[path])
+	node := newPackageGraphNode(pkg, requested[path], overrideFacts)
 	graph.Nodes = append(graph.Nodes, node)
 	graph.NodesByPackagePath[path] = node
 	graph.packagesByPath[path] = pkg
@@ -162,18 +188,18 @@ func (o *PackageGraphOwner) collect(
 	for importPath := range pkg.Imports {
 		imports = append(imports, importPath)
 	}
-	sort.Strings(imports)
+	slices.Sort(imports)
 	for _, importPath := range imports {
-		o.collect(graph, pkg.Imports[importPath], mode, requested, seen)
+		o.collect(graph, pkg.Imports[importPath], mode, requested, overrideFacts, seen)
 	}
 }
 
-func newPackageGraphNode(pkg *packages.Package, requested bool) *PackageGraphNode {
+func newPackageGraphNode(pkg *packages.Package, requested bool, overrideFacts *OverrideFacts) *PackageGraphNode {
 	imports := make([]string, 0, len(pkg.Imports))
 	for importPath := range pkg.Imports {
 		imports = append(imports, importPath)
 	}
-	sort.Strings(imports)
+	slices.Sort(imports)
 
 	var modulePath string
 	var moduleDir string
@@ -188,14 +214,19 @@ func newPackageGraphNode(pkg *packages.Package, requested bool) *PackageGraphNod
 		Name:              pkg.Name,
 		ModulePath:        modulePath,
 		ModuleDir:         moduleDir,
+		ForTest:           pkg.ForTest,
 		GoFiles:           append([]string(nil), pkg.GoFiles...),
 		CompiledGoFiles:   append([]string(nil), pkg.CompiledGoFiles...),
 		Imports:           imports,
 		Requested:         requested,
-		OverrideCandidate: hasOverrideCandidate(packagePath(pkg)),
+		OverrideCandidate: overrideFacts.HasPackage(packagePath(pkg)),
 	}
 }
 
+func isTestMainPackage(pkg *packages.Package) bool {
+	return pkg != nil && pkg.ForTest == "" && pkg.Name == "main" && strings.HasSuffix(packagePath(pkg), ".test")
+}
+
 func packagePath(pkg *packages.Package) string {
 	if pkg == nil {
 		return ""
@@ -221,11 +252,3 @@ func packageDiagnostics(pkg *packages.Package) []Diagnostic {
 	}
 	return diagnostics
 }
-
-func hasOverrideCandidate(pkgPath string) bool {
-	if pkgPath == "" {
-		return false
-	}
-	_, err := gs.GsOverrides.ReadFile("gs/" + pkgPath + "/index.ts")
-	return err == nil
-}

package/compiler/package-graph_test.go

@@ -176,6 +176,37 @@ func TestPackageGraphHonorsBuildFlags(t *testing.T) {
 	}
 }
 
+func TestPackageGraphAddsGoScriptBuildTag(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod":       "module example.test/goscripttag\n\ngo 1.25.3\n",
+		"default.go":   "package goscripttag\nconst Selected = \"default\"\n",
+		"goscript.go":  "//go:build goscript\n\npackage goscripttag\nconst GoScript = true\n",
+		"excluded.go":  "//go:build !goscript\n\npackage goscripttag\nconst Excluded = true\n",
+		"customtag.go": "//go:build customtag\n\npackage goscripttag\nconst Custom = true\n",
+	})
+	graph := loadPackageGraph(t, &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		BuildFlags:          []string{"-tags=customtag"},
+		DependencyMode:      DependencyModeRequested,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	})
+
+	var compiled []string
+	for _, file := range graph.Nodes[0].CompiledGoFiles {
+		compiled = append(compiled, filepath.Base(file))
+	}
+	for _, expected := range []string{"default.go", "goscript.go", "customtag.go"} {
+		if !slices.Contains(compiled, expected) {
+			t.Fatalf("expected %s in compiled files: %v", expected, compiled)
+		}
+	}
+	if slices.Contains(compiled, "excluded.go") {
+		t.Fatalf("did not expect excluded.go in compiled files: %v", compiled)
+	}
+}
+
 func TestPackageGraphLoadsLocalReplacement(t *testing.T) {
 	moduleDir := writePackageGraphFixture(t, map[string]string{
 		"go.mod": strings.Join([]string{
@@ -227,14 +258,67 @@ func TestPackageGraphDetectsOverrideCandidates(t *testing.T) {
 	}
 }
 
+func TestPackageGraphDetectsExternalOverrideCandidates(t *testing.T) {
+	moduleDir := writePackageGraphFixture(t, map[string]string{
+		"go.mod": strings.Join([]string{
+			"module example.test/externaloverride",
+			"",
+			"go 1.25.3",
+			"",
+			"require example.test/lib v0.0.0",
+			"replace example.test/lib => ./lib",
+			"",
+		}, "\n"),
+		"main.go": "package main\nimport \"example.test/lib\"\nfunc main() { lib.Run() }\n",
+		"lib/go.mod": strings.Join([]string{
+			"module example.test/lib",
+			"",
+			"go 1.25.3",
+			"",
+			"require example.test/heavy v0.0.0",
+			"replace example.test/heavy => ../heavy",
+			"",
+		}, "\n"),
+		"lib/lib.go":     "package lib\nimport \"example.test/heavy\"\nfunc Run() { heavy.Run() }\n",
+		"heavy/go.mod":   "module example.test/heavy\n\ngo 1.25.3\n",
+		"heavy/heavy.go": "package heavy\nfunc Run() {}\n",
+	})
+	overrideDir := filepath.Join(t.TempDir(), "gs")
+	writeFixtureFile(t, overrideDir, "example.test/lib/index.ts", "export function Run(): void {}\n")
+
+	overrideOwner := NewOverrideRegistryOwner(overrideDir)
+	req := &CompileRequest{
+		Patterns:            []string{"."},
+		Dir:                 moduleDir,
+		OutputPath:          filepath.Join(t.TempDir(), "out"),
+		DependencyMode:      DependencyModeAll,
+		RuntimeEmissionMode: RuntimeEmissionModeEmit,
+	}
+	graph, diagnostics := NewPackageGraphOwner(overrideOwner).Load(context.Background(), req)
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("package graph failed: %#v", diagnostics)
+	}
+	lib := graph.NodesByPackagePath["example.test/lib"]
+	if lib == nil || !lib.OverrideCandidate {
+		t.Fatalf("expected external override candidate for lib")
+	}
+	if graph.NodesByPackagePath["example.test/heavy"] != nil {
+		t.Fatalf("external override dependency should not be collected")
+	}
+}
+
 func TestPackageGraphOverrideCandidatesRequirePackageIndex(t *testing.T) {
 	parent := "github.com/aperturerobotics/wasivm/wazero/kernel"
 	child := parent + "/runtime"
+	facts, diagnostics := NewOverrideRegistryOwner().Facts(context.Background())
+	if diagnosticsHaveErrors(diagnostics) {
+		t.Fatalf("override facts failed: %#v", diagnostics)
+	}
 
-	if hasOverrideCandidate(parent) {
+	if facts.HasPackage(parent) {
 		t.Fatalf("parent directory without an override index was detected as an override candidate")
 	}
-	if !hasOverrideCandidate(child) {
+	if !facts.HasPackage(child) {
 		t.Fatalf("nested package with an override index was not detected as an override candidate")
 	}
 }
@@ -258,17 +342,23 @@ func writePackageGraphFixture(t *testing.T, files map[string]string) string {
 
 	dir := t.TempDir()
 	for name, contents := range files {
-		path := filepath.Join(dir, name)
-		if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
-			t.Fatal(err.Error())
-		}
-		if err := os.WriteFile(path, []byte(contents), 0o644); err != nil {
-			t.Fatal(err.Error())
-		}
+		writeFixtureFile(t, dir, name, contents)
 	}
 	return dir
 }
 
+func writeFixtureFile(t *testing.T, root, name, contents string) {
+	t.Helper()
+
+	path := filepath.Join(root, filepath.FromSlash(name))
+	if err := os.MkdirAll(filepath.Dir(path), 0o755); err != nil {
+		t.Fatal(err.Error())
+	}
+	if err := os.WriteFile(path, []byte(contents), 0o644); err != nil {
+		t.Fatal(err.Error())
+	}
+}
+
 func requireDiagnosticCode(t *testing.T, diagnostics []Diagnostic, code string) {
 	t.Helper()
 

package/compiler/package-test-function.go

@@ -0,0 +1,9 @@
+package compiler
+
+// PackageTestFunction describes one discovered ordinary Go test function.
+type PackageTestFunction struct {
+	// Name is the Go TestXxx function name.
+	Name string
+	// PackagePath is the package variant that exports the function.
+	PackagePath string
+}

package/compiler/package-test-graph-package.go

@@ -0,0 +1,40 @@
+package compiler
+
+import "golang.org/x/tools/go/packages"
+
+// PackageTestGraphPackage describes one requested package under test.
+type PackageTestGraphPackage struct {
+	// PackagePath is the package under test.
+	PackagePath string
+	// PackageName is the base package name.
+	PackageName string
+	// PackageID is the go/packages package identity for the package under test.
+	PackageID string
+	// GoFiles are the package source files.
+	GoFiles []string
+	// CompiledGoFiles are files selected by build constraints.
+	CompiledGoFiles []string
+	// SamePackageTests is the same-package test variant when present.
+	SamePackageTests *PackageTestGraphVariant
+	// ExternalPackageTests is the external-package test variant when present.
+	ExternalPackageTests *PackageTestGraphVariant
+	// Diagnostics are package or variant load diagnostics attached to this package.
+	Diagnostics []Diagnostic
+}
+
+// HasTests returns true when the package has any loaded test variant.
+func (p *PackageTestGraphPackage) HasTests() bool {
+	return p != nil && (p.SamePackageTests != nil || p.ExternalPackageTests != nil)
+}
+
+func (p *PackageTestGraphPackage) appendDiagnostics(diagnostics []Diagnostic) {
+	p.Diagnostics = append(p.Diagnostics, diagnostics...)
+}
+
+func (p *PackageTestGraphPackage) setPackage(pkg *packages.Package) {
+	p.PackagePath = packagePath(pkg)
+	p.PackageName = pkg.Name
+	p.PackageID = pkg.ID
+	p.GoFiles = append([]string(nil), pkg.GoFiles...)
+	p.CompiledGoFiles = append([]string(nil), pkg.CompiledGoFiles...)
+}