avoid reflect method call panics with GOGARBLE=*

We were obfuscating reflect's package path and its declared names,
but the toolchain wants to detect the presence of method reflection
to turn down the aggressiveness of dead code elimination.

Given that the obfuscation broke the detection,
we could easily end up in crashes when making reflect calls:

	fatal error: unreachable method called. linker bug?

	goroutine 1 [running]:
	runtime.throw({0x50c9b3?, 0x2?})
		runtime/panic.go:1047 +0x5d fp=0xc000063660 sp=0xc000063630 pc=0x43245d
	runtime.unreachableMethod()
		runtime/iface.go:532 +0x25 fp=0xc000063680 sp=0xc000063660 pc=0x40a845
	runtime.call16(0xc00010a360, 0xc00000e0a8, 0x0, 0x0, 0x0, 0x8, 0xc000063bb0)
		runtime/wcS9OpRFL:728 +0x49 fp=0xc0000636a0 sp=0xc000063680 pc=0x45eae9
	runtime.reflectcall(0xc00001c120?, 0x1?, 0x1?, 0x18110?, 0xc0?, 0x1?, 0x1?)
		<autogenerated>:1 +0x3c fp=0xc0000636e0 sp=0xc0000636a0 pc=0x462e9c

Avoid obfuscating the three names which cause problems: "reflect",
"Method", and "MethodByName".

While here, we also teach obfuscatedImportPath to skip "runtime",
as I also saw that the toolchain detects it for many reasons.
That wasn't a problem yet, as we do not obfuscate the runtime,
but it was likely going to become a problem in the future.

main.go

@@ -1741,12 +1741,19 @@ func (tf *transformer) transformGo(file *ast.File) *ast.File {
 			return true // universe scope
 		}
 
-		if pkg.Path() == "embed" {
+		// The Go toolchain needs to detect symbols from these packages,
-			// The Go compiler needs to detect types such as embed.FS.
+		// so we are not obfuscating their package paths or declared names.
-			// That will fail if we change the import path or type name.
+		switch pkg.Path() {
-			// Leave it as is.
+		case "embed":
-			// Luckily, the embed package just declares the FS type.
+			// FS is detected by the compiler for //go:embed.
-			return true
+			return name == "FS"
+		case "reflect":
+			// Per the linker's deadcode.go docs,
+			// the Method and MethodByName methods are what drive the logic.
+			switch name {
+			case "Method", "MethodByName":
+				return true
+			}
 		}
 
 		// The package that declared this object did not obfuscate it.

shared.go

@@ -158,9 +158,17 @@ type listedPackage struct {
 }
 
 func (p *listedPackage) obfuscatedImportPath() string {
-	// We can't obfuscate the embed package's import path,
+	// We can't obfuscate these standard library import paths,
-	// as the toolchain expects to recognize the package by it.
+	// as the toolchain expects to recognize the packages by them:
-	if p.ImportPath == "embed" || !p.ToObfuscate {
+	//
+	//   * runtime: it is special in many ways
+	//   * reflect: its presence turns down dead code elimination
+	//   * embed: its presence enables using //go:embed
+	switch p.ImportPath {
+	case "runtime", "reflect", "embed":
+		return p.ImportPath
+	}
+	if !p.ToObfuscate {
 		return p.ImportPath
 	}
 	newPath := hashWithPackage(p, p.ImportPath)

testdata/script/reflect.txtar

@@ -41,13 +41,9 @@ func main() {
 	printfWithoutPackage("%T\n", importedpkg.ReflectTypeOf(2))
 	printfWithoutPackage("%T\n", importedpkg.ReflectTypeOfIndirect(4))
 
-
 	// More complex use of reflect.
 	v := importedpkg.ReflectValueOfVar
 	printfWithoutPackage("%#v\n", v)
-	// Keep the method from being unreachable, otherwise Call below may panic.
-	// TODO(mvdan): This only started being necessary with GOGARBLE=*. Why?
-	Sink = v.ExportedMethodName
 	method := reflect.ValueOf(&v).MethodByName("ExportedMethodName")
 	if method.IsValid() {
 		fmt.Println(method.Call(nil))