fix: avoid panic on new stdlib packages (#173)

Author: jupblb

internal/loader/loader.go

@@ -3,6 +3,7 @@ package loader
 import (
 	"fmt"
 	"io/ioutil"
+	"os"
 	"strings"
 
 	"github.com/charmbracelet/log"
@@ -145,21 +146,8 @@ func IsStandardLib(pkg *packages.Package) bool {
 	//  -> github.com/
 	//  -> false
 	base := strings.Split(pkg.PkgPath, "/")[0]
-	if _, ok := stdPackages[base]; ok {
-		return ok
-	}
-
-	noTestPackage := strings.Replace(base, "_test", "", -1)
-	if _, ok := stdPackages[noTestPackage]; ok {
-		return ok
-	}
-
-	noTestPsuedoPackage := strings.Replace(base, ".test", "", -1)
-	if _, ok := stdPackages[noTestPsuedoPackage]; ok {
-		return ok
-	}
-
-	return false
+	_, ok := getStdlibPackages()[base]
+	return ok
 }
 
 func normalizePackage(opts *config.IndexOpts, pkg *packages.Package) *packages.Package {
@@ -204,11 +192,14 @@ func normalizePackage(opts *config.IndexOpts, pkg *packages.Package) *packages.P
 		pkg.PkgPath = strings.TrimPrefix(pkg.PkgPath, "std/")
 	} else {
 		if pkg.Module == nil {
-			panic(fmt.Sprintf(
-				"Should not be possible to have nil module for userland package: %s %s",
-				pkg,
-				pkg.PkgPath,
-			))
+			log.Warn("Package has nil Module, using fallback",
+				"package", pkg.PkgPath,
+				"driver", os.Getenv("GOPACKAGESDRIVER"))
+			
+			pkg.Module = &packages.Module{
+				Path:    ".",
+				Version: ".",
+			}
 		}
 	}
 

internal/loader/stdlib_dynamic.go

@@ -0,0 +1,52 @@
+package loader
+
+import (
+	"os"
+	"os/exec"
+	"strings"
+	"sync"
+
+	"github.com/charmbracelet/log"
+)
+
+var (
+	stdlibOnce sync.Once
+	stdlibMap  map[string]struct{}
+)
+
+func getStdlibPackages() map[string]struct{} {
+	stdlibOnce.Do(func() {
+		stdlibMap = stdPackages
+
+		if os.Getenv("GOPACKAGESDRIVER") != "" {
+			log.Debug("GOPACKAGESDRIVER is set, using hardcoded stdlib list")
+			return
+		}
+
+		cmd, err := exec.LookPath("go")
+		if err != nil {
+			log.Warn("go command not found, using hardcoded stdlib list")
+			return
+		}
+
+		output, err := exec.Command(cmd, "list", "std").Output()
+		if err != nil {
+			log.Warn(
+				"Failed to run 'go list std', using hardcoded stdlib list", "error", err)
+			return
+		}
+
+		stdlibMap = make(map[string]struct{})
+		packages := strings.SplitSeq(strings.TrimSpace(string(output)), "\n")
+		for pkg := range packages {
+			if pkg == "" {
+				continue
+			}
+			base := strings.Split(pkg, "/")[0]
+			stdlibMap[base] = struct{}{}
+		}
+		
+		log.Debug("Successfully loaded stdlib packages dynamically", "count", len(stdlibMap))
+	})
+	return stdlibMap
+}

internal/loader/stdlib_dynamic_test.go

@@ -0,0 +1,46 @@
+package loader
+
+import (
+	"sync"
+	"testing"
+
+	"golang.org/x/tools/go/packages"
+)
+
+func TestStdlibDetectionNoBazel(t *testing.T) {
+	// Add a test-only package to the hardcoded list to verify different behavior
+	// between dynamic loading and hardcoded list
+	stdPackages["testonly"] = struct{}{}
+	t.Cleanup(func() {
+		delete(stdPackages, "testonly")
+	})
+
+	testCases := []struct {
+		pkgPath          string
+		isStdlib         bool
+		goPackagesDriver string
+	}{
+		{"fmt", true, ""},
+		{"net/http", true, ""},
+		{"encoding/json", true, ""},
+		{"vendor/golang.org/x/crypto/chacha20", true, ""},
+		{"github.com/sourcegraph/scip-go", false, ""},
+		{"golang.org/x/tools", false, ""},
+		{"vendorapi.com/foo", false, ""},
+		{"testonly", false, ""},
+		{"testonly", true, "bazel"},
+	}
+
+	t.Run("DynamicLoading", func(t *testing.T) {
+		for _, tc := range testCases {
+			stdlibOnce = sync.Once{}
+			t.Setenv("GOPACKAGESDRIVER", tc.goPackagesDriver)
+
+			pkg := &packages.Package{PkgPath: tc.pkgPath}
+			if got := IsStandardLib(pkg); got != tc.isStdlib {
+				t.Errorf("IsStandardLib(%q) = %v, want %v",
+					tc.pkgPath, got, tc.isStdlib)
+			}
+		}
+	})
+}