clean up the function that walks the syntax tree

Avoiding a type switch for the entire node prevents an indentation
level.

We can obtain obj and pkg early, and return early as well if either is
uninteresting. That means less nil checks later on, which means even
less indentation and complexity.

main.go

@@ -454,79 +454,80 @@ func transformGo(file *ast.File, info *types.Info) *ast.File {
 	}
 
 	pre := func(cursor *astutil.Cursor) bool {
-		switch node := cursor.Node().(type) {
+		node, ok := cursor.Node().(*ast.Ident)
-		case *ast.Ident:
+		if !ok {
-			if node.Name == "_" {
+			return true
-				return true // unnamed remains unnamed
+		}
+		if node.Name == "_" {
+			return true // unnamed remains unnamed
+		}
+		if strings.HasPrefix(node.Name, "_C") || strings.Contains(node.Name, "_cgo") {
+			return true // don't mess with cgo-generated code
+		}
+		obj := info.ObjectOf(node)
+		if obj == nil {
+			switch cursor.Parent().(type) {
+			case *ast.AssignStmt:
+				// symbolic var v in v := expr.(type)
+				node.Name = hashWith(buildInfo.buildID, node.Name)
+			}
+			return true
+		}
+		pkg := obj.Pkg()
+		if pkg == nil {
+			return true // universe scope
+		}
+		// log.Printf("%#v %T", node, obj)
+		switch x := obj.(type) {
+		case *types.Var:
+			if x.Embedded() {
+				obj = objOf(obj.Type())
+				pkg = obj.Pkg()
+			} else if x.IsField() && x.Exported() {
+				// might be used for reflection, e.g.
+				// encoding/json without struct tags
+				return true
 			}
-			if strings.HasPrefix(node.Name, "_C") || strings.Contains(node.Name, "_cgo") {
+		case *types.Const:
-				return true // don't mess with cgo-generated code
+		case *types.TypeName:
+		case *types.Func:
+			sign := obj.Type().(*types.Signature)
+			if obj.Exported() && sign.Recv() != nil {
+				return true // might implement an interface
 			}
-			obj := info.ObjectOf(node)
+			if implementedOutsideGo(x) {
-			// log.Printf("%#v %T", node, obj)
+				return true // give up in this case
-			switch x := obj.(type) {
+			}
-			case *types.Var:
+			switch node.Name {
-				if x.Embedded() {
+			case "main", "init", "TestMain":
-					obj = objOf(obj.Type())
+				return true // don't break them
-				} else if x.IsField() && x.Exported() {
+			}
-					// might be used for reflection, e.g.
+			if strings.HasPrefix(node.Name, "Test") && isTestSignature(sign) {
-					// encoding/json without struct tags
+				return true // don't break tests
-					return true
+			}
-				}
+		default:
-			case *types.Const:
+			return true // we only want to rename the above
-			case *types.TypeName:
+		}
-			case *types.Func:
+		buildID := buildInfo.buildID
-				sign := obj.Type().(*types.Signature)
+		path := pkg.Path()
-				if obj.Exported() && sign.Recv() != nil {
+		if !isPrivate(path) {
-					return true // might implement an interface
+			return true // only private packages are transformed
-				}
+		}
-				if implementedOutsideGo(x) {
+		if id := buildInfo.imports[path].buildID; id != "" {
-					return true // give up in this case
+			garbledPkg, err := garbledImport(path)
-				}
+			if err != nil {
-				switch node.Name {
+				panic(err) // shouldn't happen
-				case "main", "init", "TestMain":
-					return true // don't break them
-				}
-				if strings.HasPrefix(node.Name, "Test") && isTestSignature(sign) {
-					return true // don't break tests
-				}
-			case nil:
-				switch cursor.Parent().(type) {
-				case *ast.AssignStmt:
-					// symbolic var v in v := expr.(type)
-				default:
-					return true
-				}
-			default:
-				return true // we only want to rename the above
 			}
-			buildID := buildInfo.buildID
+			// Check if the imported name wasn't
-			if obj != nil {
+			// garbled, e.g. if it's assembly.
-				pkg := obj.Pkg()
+			if garbledPkg.Scope().Lookup(obj.Name()) != nil {
-				if pkg == nil {
+				return true
-					return true // universe scope
-				}
-				path := pkg.Path()
-				if !isPrivate(path) {
-					return true // only private packages are transformed
-				}
-				if id := buildInfo.imports[path].buildID; id != "" {
-					garbledPkg, err := garbledImport(path)
-					if err != nil {
-						panic(err) // shouldn't happen
-					}
-					// Check if the imported name wasn't
-					// garbled, e.g. if it's assembly.
-					if garbledPkg.Scope().Lookup(obj.Name()) != nil {
-						return true
-					}
-					buildID = id
-				}
 			}
-			// orig := node.Name
+			buildID = id
-			node.Name = hashWith(buildID, node.Name)
-			// log.Printf("%q hashed with %q to %q", orig, buildID, node.Name)
 		}
+		// orig := node.Name
+		node.Name = hashWith(buildID, node.Name)
+		// log.Printf("%q hashed with %q to %q", orig, buildID, node.Name)
 		return true
 	}
 	return astutil.Apply(file, pre, nil).(*ast.File)