Misc small tidy-ups mostly suggested by linter

Author: owen-mc

go/extractor/extractor.go

@@ -199,7 +199,7 @@ func ExtractWithFlags(buildFlags []string, patterns []string) error {
 
 	// extract AST information for all packages
 	packages.Visit(pkgs, nil, func(pkg *packages.Package) {
-		for root, _ := range wantedRoots {
+		for root := range wantedRoots {
 			pkgInfo := pkgInfos[pkg.PkgPath]
 			relDir, err := filepath.Rel(root, pkgInfo.PkgDir)
 			if err != nil || noExtractRe.MatchString(relDir) {
@@ -397,15 +397,15 @@ func extractObjects(tw *trap.Writer, scope *types.Scope, scopeLabel trap.Label)
 			// do not appear as objects in any scope, so they have to be dealt
 			// with separately in extractMethods.
 			if funcObj, ok := obj.(*types.Func); ok {
-				populateTypeParamParents(tw, funcObj.Type().(*types.Signature).TypeParams(), obj)
-				populateTypeParamParents(tw, funcObj.Type().(*types.Signature).RecvTypeParams(), obj)
+				populateTypeParamParents(funcObj.Type().(*types.Signature).TypeParams(), obj)
+				populateTypeParamParents(funcObj.Type().(*types.Signature).RecvTypeParams(), obj)
 			}
 			// Populate type parameter parents for named types. Note that we
 			// skip type aliases as the original type should be the parent
 			// of any type parameters.
 			if typeNameObj, ok := obj.(*types.TypeName); ok && !typeNameObj.IsAlias() {
 				if tp, ok := typeNameObj.Type().(*types.Named); ok {
-					populateTypeParamParents(tw, tp.TypeParams(), obj)
+					populateTypeParamParents(tp.TypeParams(), obj)
 				}
 			}
 			extractObject(tw, obj, lbl)
@@ -431,8 +431,8 @@ func extractMethod(tw *trap.Writer, meth *types.Func) trap.Label {
 	if !exists {
 		// Populate type parameter parents for methods. They do not appear as
 		// objects in any scope, so they have to be dealt with separately here.
-		populateTypeParamParents(tw, meth.Type().(*types.Signature).TypeParams(), meth)
-		populateTypeParamParents(tw, meth.Type().(*types.Signature).RecvTypeParams(), meth)
+		populateTypeParamParents(meth.Type().(*types.Signature).TypeParams(), meth)
+		populateTypeParamParents(meth.Type().(*types.Signature).RecvTypeParams(), meth)
 		extractObject(tw, meth, methlbl)
 	}
 
@@ -490,7 +490,7 @@ func extractObject(tw *trap.Writer, obj types.Object, lbl trap.Label) {
 func extractObjectTypes(tw *trap.Writer) {
 	// calling `extractType` on a named type will extract all methods defined
 	// on it, which will add new objects. Therefore we need to do this first
-	// before we loops over all objects and emit them.
+	// before we loop over all objects and emit them.
 	changed := true
 	for changed {
 		changed = tw.ForEachObject(extractObjectType)
@@ -1129,11 +1129,9 @@ func extractExpr(tw *trap.Writer, expr ast.Expr, parent trap.Label, idx int) {
 // each child over its preceding child (usually either 1 for assigning increasing indices, or
 // -1 for decreasing indices)
 func extractExprs(tw *trap.Writer, exprs []ast.Expr, parent trap.Label, idx int, dir int) {
-	if exprs != nil {
-		for _, expr := range exprs {
-			extractExpr(tw, expr, parent, idx)
-			idx += dir
-		}
+	for _, expr := range exprs {
+		extractExpr(tw, expr, parent, idx)
+		idx += dir
 	}
 }
 
@@ -1389,13 +1387,10 @@ func extractStmt(tw *trap.Writer, stmt ast.Stmt, parent trap.Label, idx int) {
 // each child over its preceding child (usually either 1 for assigning increasing indices, or
 // -1 for decreasing indices)
 func extractStmts(tw *trap.Writer, stmts []ast.Stmt, parent trap.Label, idx int, dir int) {
-	if stmts != nil {
-		for _, stmt := range stmts {
-			extractStmt(tw, stmt, parent, idx)
-			idx += dir
-		}
+	for _, stmt := range stmts {
+		extractStmt(tw, stmt, parent, idx)
+		idx += dir
 	}
-
 }
 
 // extractDecl extracts AST information for the given declaration
@@ -1944,7 +1939,7 @@ func extractTypeParamDecls(tw *trap.Writer, fields *ast.FieldList, parent trap.L
 }
 
 // populateTypeParamParents sets `parent` as the parent of the elements of `typeparams`
-func populateTypeParamParents(tw *trap.Writer, typeparams *types.TypeParamList, parent types.Object) {
+func populateTypeParamParents(typeparams *types.TypeParamList, parent types.Object) {
 	if typeparams != nil {
 		for idx := 0; idx < typeparams.Len(); idx++ {
 			setTypeParamParent(typeparams.At(idx), parent)
@@ -1966,16 +1961,6 @@ func getObjectBeingUsed(tw *trap.Writer, ident *ast.Ident) types.Object {
 	}
 }
 
-// tryGetGenericType returns the generic type of `tp`, and a boolean indicating
-// whether it is the same as `tp`.
-func tryGetGenericType(tp types.Type) (*types.Named, bool) {
-	if namedType, ok := tp.(*types.Named); ok {
-		originType := namedType.Origin()
-		return originType, namedType == originType
-	}
-	return nil, false
-}
-
 // trackInstantiatedStructFields tries to give the fields of an instantiated
 // struct type underlying `tp` the same labels as the corresponding fields of
 // the generic struct type. This is so that when we come across the