Implement struct slop detection rules (#5)

Based on go/types.Sizes interface to re-arrange struct fields for optimal size.

Fixes #3

Co-authored-by: Cuong Manh Le <cuong@orijtech.com>

Author: cuonglm

structslop.go

@@ -1,7 +1,11 @@
 package structslop
 
 import (
+	"fmt"
 	"go/ast"
+	"go/build"
+	"go/types"
+	"sort"
 
 	"golang.org/x/tools/go/analysis"
 	"golang.org/x/tools/go/analysis/passes/inspect"
@@ -25,11 +29,92 @@ func run(pass *analysis.Pass) (interface{}, error) {
 		(*ast.StructType)(nil),
 	}
 	inspect.Preorder(nodeFilter, func(n ast.Node) {
-		s := n.(*ast.StructType)
-		if s.Fields.NumFields() < 2 {
+		atyp := n.(*ast.StructType)
+		styp, ok := pass.TypesInfo.Types[atyp].Type.(*types.Struct)
+		// Type information may be incomplete.
+		if !ok {
 			return
 		}
-		pass.Reportf(s.Pos(), "not implemented")
+
+		if styp.NumFields() < 2 {
+			return
+		}
+
+		r := checkSloppy(styp)
+		if !r.sloppy() {
+			return
+		}
+
+		pass.Report(analysis.Diagnostic{
+			Pos:     n.Pos(),
+			End:     n.End(),
+			Message: fmt.Sprintf("%v has size %d, could be %d, rearrange to %v for optimal size", styp, r.oldSize, r.newSize, r.suggestedStruct),
+			SuggestedFixes: []analysis.SuggestedFix{{
+				Message: fmt.Sprintf("Rearrange struct fields: %v", r.suggestedStruct),
+				TextEdits: []analysis.TextEdit{
+					{
+						Pos:     n.Pos(),
+						End:     n.End(),
+						NewText: []byte(fmt.Sprintf("%v", r.suggestedStruct)),
+					},
+				},
+			}},
+		})
 	})
 	return nil, nil
 }
+
+var sizes = types.SizesFor(build.Default.Compiler, build.Default.GOARCH)
+
+type result struct {
+	oldSize         int64
+	newSize         int64
+	suggestedStruct *types.Struct
+}
+
+func (r result) sloppy() bool {
+	return r.oldSize > r.newSize
+}
+
+func checkSloppy(origStruct *types.Struct) result {
+	optStruct := optimalStructArrangement(origStruct)
+	return result{
+		oldSize:         sizes.Sizeof(origStruct),
+		newSize:         sizes.Sizeof(optStruct),
+		suggestedStruct: optStruct,
+	}
+}
+
+func optimalStructArrangement(s *types.Struct) *types.Struct {
+	nf := s.NumFields()
+	// TODO (cuonglm): for struct has first field is "_ [0]func()", we should not move it.
+	fields := make([]*types.Var, nf)
+	for i := 0; i < nf; i++ {
+		fields[i] = s.Field(i)
+	}
+
+	sort.Slice(fields, func(i, j int) bool {
+		ti, tj := fields[i].Type(), fields[j].Type()
+		si, sj := sizes.Sizeof(ti), sizes.Sizeof(tj)
+
+		if si == 0 && sj != 0 {
+			return true
+		}
+		if sj == 0 && si != 0 {
+			return false
+		}
+
+		ai, aj := sizes.Alignof(ti), sizes.Alignof(tj)
+		if ai != aj {
+			return ai > aj
+		}
+
+		if si != sj {
+			return si > sj
+		}
+
+		return false
+	})
+
+	return types.NewStruct(fields, nil)
+}

testdata/src/struct/p.go

@@ -6,7 +6,21 @@ type s1 struct {
 	i int
 }
 
-type s2 struct { // want "not implemented"
+type s2 struct {
 	i int
 	j int
 }
+
+type s3 struct { // want "struct{.+} has size 20, could be 16, rearrange to struct{y uint64; x uint32; z uint32} for optimal size"
+	x uint32
+	y uint64
+	z uint32
+}
+
+type s4 struct { // want `struct{.+} has size 32, could be 20, rearrange to struct{_ \[0\]func\(\); i1 int; i2 int; a3 \[3\]bool; b bool} for optimal size`
+	b  bool
+	i1 int
+	i2 int
+	a3 [3]bool
+	_  [0]func()
+}