use lpkg directly in reflectInspector

There's no need to reach for sharedCache.ListedPackages
when the caller is computePkgCache, which already has the lpkg value.

While here, compare *go/types.Package pointers directly
rather than via their import path strings.

main.go

@@ -1589,6 +1589,7 @@ func computePkgCache(fsCache *cache.Cache, lpkg *listedPackage, pkg *types.Packa
 
 	// Fill the reflect info from SSA, which builds on top of the syntax tree and type info.
 	inspector := reflectInspector{
+		lpkg:            lpkg,
 		pkg:             pkg,
 		checkedAPIs:     make(map[string]bool),
 		propagatedInstr: map[ssa.Instruction]bool{},

reflect.go

@@ -11,7 +11,8 @@ import (
 )
 
 type reflectInspector struct {
-	pkg *types.Package
+	lpkg *listedPackage
+	pkg  *types.Package
 
 	checkedAPIs map[string]bool
 
@@ -189,13 +190,13 @@ func (ri *reflectInspector) checkFunction(fun *ssa.Function) {
 			switch inst := inst.(type) {
 			case *ssa.Store:
 				obj := typeToObj(inst.Addr.Type())
-				if obj != nil && usedForReflect(ri.result, obj) {
+				if obj != nil && ri.usedForReflect(ri.result, obj) {
 					ri.recordArgReflected(inst.Val, make(map[ssa.Value]bool))
 					ri.propagatedInstr[inst] = true
 				}
 			case *ssa.ChangeType:
 				obj := typeToObj(inst.X.Type())
-				if obj != nil && usedForReflect(ri.result, obj) {
+				if obj != nil && ri.usedForReflect(ri.result, obj) {
 					ri.recursivelyRecordUsedForReflect(inst.Type(), nil)
 					ri.propagatedInstr[inst] = true
 				}
@@ -395,7 +396,7 @@ func (ri *reflectInspector) recursivelyRecordUsedForReflect(t types.Type, parent
 		if obj.Pkg() == nil || obj.Pkg() != ri.pkg {
 			return // not from the specified package
 		}
-		if usedForReflect(ri.result, obj) {
+		if ri.usedForReflect(ri.result, obj) {
 			return // prevent endless recursion
 		}
 		ri.recordUsedForReflect(obj, parent)
@@ -466,7 +467,7 @@ func recordedObjectString(obj types.Object) objectString {
 
 // obfuscatedObjectName returns the obfucated name of a types.Object,
 // parent is needed to correctly get the obfucated name of struct fields
-func obfuscatedObjectName(obj types.Object, parent *types.Struct) string {
+func (ri *reflectInspector) obfuscatedObjectName(obj types.Object, parent *types.Struct) string {
 	pkg := obj.Pkg()
 	if pkg == nil {
 		return "" // builtin types are never obfuscated
@@ -476,25 +477,24 @@ func obfuscatedObjectName(obj types.Object, parent *types.Struct) string {
 		return hashWithStruct(parent, v)
 	}
 
-	lpkg := sharedCache.ListedPackages[obj.Pkg().Path()]
+	return hashWithPackage(ri.lpkg, obj.Name())
-	return hashWithPackage(lpkg, obj.Name())
 }
 
 // recordUsedForReflect records the objects whose names we cannot obfuscate due to reflection.
 // We currently record named types and fields.
 func (ri *reflectInspector) recordUsedForReflect(obj types.Object, parent *types.Struct) {
-	if obj.Pkg().Path() != ri.pkg.Path() {
+	if obj.Pkg() != ri.pkg {
 		panic("called recordUsedForReflect with a foreign object")
 	}
-	obfName := obfuscatedObjectName(obj, parent)
+	obfName := ri.obfuscatedObjectName(obj, parent)
 	if obfName == "" {
 		return
 	}
 	ri.result.ReflectObjectNames[obfName] = obj.Name()
 }
 
-func usedForReflect(cache pkgCache, obj types.Object) bool {
+func (ri *reflectInspector) usedForReflect(cache pkgCache, obj types.Object) bool {
-	obfName := obfuscatedObjectName(obj, nil)
+	obfName := ri.obfuscatedObjectName(obj, nil)
 	if obfName == "" {
 		return false
 	}