support aliases as embedded fields in dependencies

Our recent work in fieldToAlias worked well when the embedded field
declaration (using an alias) was in the same package as the use of that
field. We would have the *ast.Ident for the field declaration, so
types.Info.Uses would give us the TypeName for the alias.

Unfortunately, if the declaration was in a dependency package, we did
not have that same *ast.Ident, as we weren't parsing the source code for
dependencies for type-checking. This resulted in us incorrectly
obfuscating the use of such an embedded field:

	> garble build
	[stderr]
	# test/main
	JtzmzxWf.go:4: unknown field 'ExternalForeignAlias' in struct literal of type _BdSNiEL.Vcs_smer

To fix this, look through the direct imports of the package defining the
field to find an alias under the exact same name. Not a foolproof
solution, as there's a TODO, but it should work for most cases.

Fixes the obfuscation of google.golang.org/grpc/internal/status, too.

Updates #349.

main.go

@@ -1169,14 +1169,15 @@ func (tf *transformer) transformGo(file *ast.File) *ast.File {
 		}
 		pkg := obj.Pkg()
 		if vr, ok := obj.(*types.Var); ok && vr.Embedded() {
+
 			// The docs for ObjectOf say:
 			//
 			//     If id is an embedded struct field, ObjectOf returns the
 			//     field (*Var) it defines, not the type (*TypeName) it uses.
 			//
 			// If this embedded field is a type alias, we want to
-			// handle that instead of treating it as the type the
-			// alias points to.
+			// handle the alias's TypeName instead of treating it as
+			// the type the alias points to.
 			//
 			// Alternatively, if we don't have an alias, we want to
 			// use the embedded type, not the field.
@@ -1190,8 +1191,25 @@ func (tf *transformer) transformGo(file *ast.File) *ast.File {
 				if named == nil {
 					return true // unnamed type (probably a basic type, e.g. int)
 				}
+				// If the field embeds an alias,
+				// and the field is declared in a dependency,
+				// fieldToAlias might not tell us about the alias.
+				// We lack the *ast.Ident for the field declaration,
+				// so we can't see it in types.Info.Uses.
+				//
+				// Instead, detect such a "foreign alias embed".
+				// If we embed a final named type,
+				// but the field name does not match its name,
+				// then it must have been done via an alias.
+				// We dig out the alias's TypeName via locateForeignAlias.
+				if named.Obj().Name() != node.Name {
+					tname := locateForeignAlias(vr.Pkg().Path(), node.Name)
+					tf.fieldToAlias[vr] = tname // to reuse it later
+					obj = tname
+				} else {
 					obj = named.Obj()
 				}
+			}
 			pkg = obj.Pkg()
 		}
 		if pkg == nil {
@@ -1359,6 +1377,44 @@ func (tf *transformer) transformGo(file *ast.File) *ast.File {
 	return astutil.Apply(file, pre, post).(*ast.File)
 }
 
+// locateForeignAlias finds the TypeName for an alias by the name aliasName,
+// which must be declared in one of the dependencies of dependentImportPath.
+func locateForeignAlias(dependentImportPath, aliasName string) *types.TypeName {
+	var found *types.TypeName
+	lpkg, err := listPackage(dependentImportPath)
+	if err != nil {
+		panic(err) // shouldn't happen
+	}
+	for _, importedPath := range lpkg.Imports {
+		pkg2, err := origImporter.ImportFrom(importedPath, opts.GarbleDir, 0)
+		if err != nil {
+			panic(err)
+		}
+		tname, ok := pkg2.Scope().Lookup(aliasName).(*types.TypeName)
+		if ok && tname.IsAlias() {
+			if found != nil {
+				// We assume that the alias is declared exactly
+				// once in the set of direct imports.
+				// This might not be the case, e.g. if two
+				// imports declare the same alias name.
+				//
+				// TODO: Think how we could solve that
+				// efficiently, if it happens in practice.
+				panic(fmt.Sprintf("found multiple TypeNames for %s", aliasName))
+			}
+			found = tname
+		}
+	}
+	if found == nil {
+		// This should never happen.
+		// If package A embeds an alias declared in a dependency,
+		// it must show up in the form of "B.Alias",
+		// so A must import B and B must declare "Alias".
+		panic(fmt.Sprintf("could not find TypeName for %s", aliasName))
+	}
+	return found
+}
+
 // recordIgnore adds any named types (including fields) under typ to
 // ignoreObjects.
 //

shared.go

@@ -169,6 +169,7 @@ type listedPackage struct {
 
 	Dir     string
 	GoFiles []string
+	Imports []string
 
 	// The fields below are not part of 'go list', but are still reused
 	// between garble processes. Use "Garble" as a prefix to ensure no

testdata/scripts/syntax.txt

@@ -100,6 +100,11 @@ func main() {
 	println(extra.Func())
 	sub.Test()
 	neverInlined()
+
+	_ = sub.EmbeddingExternalForeignAlias{
+		ExternalForeignAlias: nil,
+		Reader:       nil,
+	}
 }
 
 -- scopes.go --
@@ -135,7 +140,11 @@ func input(localNameParam string) (localNameReturn string) { return localNamePar
 -- sub/names.go --
 package sub
 
-import "io"
+import (
+	"io"
+
+	"test/main/external"
+)
 
 var someGlobalVar0 = "0"
 var someGlobalVar1 = "1"
@@ -184,6 +193,35 @@ var _ = embeddingForeignAlias{
 	Reader: nil,
 }
 
+// Similar to embeddingForeignAlias,
+// but the alias is declared in a dependency,
+// and this type is used in a dependent.
+type EmbeddingExternalForeignAlias struct {
+	external.ExternalForeignAlias
+	io.Reader
+}
+
+// Like the cases above,
+// but this time the alias doesn't rename its destination named type.
+// We can't tell this apart from "struct { io.Reader }" at the type info level.
+// It's fine to ignore the alias entirely, in this case.
+type embeddingAliasSameName struct {
+	external.Reader
+}
+
+var _ = embeddingAliasSameName{
+	Reader: nil,
+}
+
+-- external/external.go --
+package external
+
+import "io"
+
+type ExternalForeignAlias = io.Reader
+
+type Reader = io.Reader
+
 -- main.stderr --
 nil case
 1 1 1