fix optional proto fields false positive

processor.go

@@ -87,6 +87,50 @@ func (c *processor) process(n ast.Node) (*Result, error) {
 		c.writeFrom("*")
 		c.processInner(x.X)
 
+	case *ast.BinaryExpr:
+		// Check if the expression is a comparison.
+		if x.Op != token.EQL && x.Op != token.NEQ {
+			return &Result{}, nil
+		}
+
+		// Check if one of the operands is nil.
+
+		xIdent, xOk := x.X.(*ast.Ident)
+		yIdent, yOk := x.Y.(*ast.Ident)
+
+		xIsNil := xOk && xIdent.Name == "nil"
+		yIsNil := yOk && yIdent.Name == "nil"
+
+		if !xIsNil && !yIsNil {
+			return &Result{}, nil
+		}
+
+		// Extract the non-nil operand for further checks
+
+		var expr ast.Expr
+		if xIsNil {
+			expr = x.Y
+		} else {
+			expr = x.X
+		}
+
+		se, ok := expr.(*ast.SelectorExpr)
+		if !ok {
+			return &Result{}, nil
+		}
+
+		if !isProtoMessage(c.info, se.X) {
+			return &Result{}, nil
+		}
+
+		// Check if the Getter function of the protobuf message returns a pointer.
+		hasPointer, ok := getterResultHasPointer(c.info, se.X, se.Sel.Name)
+		if !ok || hasPointer {
+			return &Result{}, nil
+		}
+
+		c.filter.AddPos(x.X.Pos())
+
 	default:
 		return nil, fmt.Errorf("not implemented for type: %s (%s)", reflect.TypeOf(x), formatNode(n))
 	}
@@ -225,14 +269,14 @@ func isProtoMessage(info *types.Info, expr ast.Expr) bool {
 	return false
 }
 
-func methodIsExists(info *types.Info, x ast.Expr, name string) bool {
+func typesNamed(info *types.Info, x ast.Expr) (*types.Named, bool) {
 	if info == nil {
-		return false
+		return nil, false
 	}
 
 	t := info.TypeOf(x)
 	if t == nil {
-		return false
+		return nil, false
 	}
 
 	ptr, ok := t.Underlying().(*types.Pointer)
@@ -241,6 +285,15 @@ func methodIsExists(info *types.Info, x ast.Expr, name string) bool {
 	}
 
 	named, ok := t.(*types.Named)
+	if !ok {
+		return nil, false
+	}
+
+	return named, true
+}
+
+func methodIsExists(info *types.Info, x ast.Expr, name string) bool {
+	named, ok := typesNamed(info, x)
 	if !ok {
 		return false
 	}
@@ -253,3 +306,38 @@ func methodIsExists(info *types.Info, x ast.Expr, name string) bool {
 
 	return false
 }
+
+func getterResultHasPointer(info *types.Info, x ast.Expr, name string) (hasPointer, ok bool) {
+	named, ok := typesNamed(info, x)
+	if !ok {
+		return false, false
+	}
+
+	for i := 0; i < named.NumMethods(); i++ {
+		method := named.Method(i)
+		if method.Name() != "Get"+name {
+			continue
+		}
+
+		var sig *types.Signature
+		sig, ok = method.Type().(*types.Signature)
+		if !ok {
+			return false, false
+		}
+
+		results := sig.Results()
+		if results.Len() == 0 {
+			return false, false
+		}
+
+		firstType := results.At(0)
+		_, ok = firstType.Type().(*types.Pointer)
+		if !ok {
+			return false, true
+		}
+
+		return true, true
+	}
+
+	return false, false
+}

protogetter.go

@@ -97,6 +97,7 @@ func Run(pass *analysis.Pass, cfg *Config) ([]Issue, error) {
 
 	nodeTypes := []ast.Node{
 		(*ast.AssignStmt)(nil),
+		(*ast.BinaryExpr)(nil),
 		(*ast.CallExpr)(nil),
 		(*ast.SelectorExpr)(nil),
 		(*ast.StarExpr)(nil),

testdata/proto/test.proto

@@ -17,6 +17,13 @@ message Test {
 
   // issue #4
   optional bool opt_bool = 12;
+
+  // Optional enum
+  enum OEnum {
+    O_ENUM1 = 0;
+    O_ENUM2 = 1;
+  }
+  optional OEnum opt_enum = 13;
 }
 
 message Embedded {

testdata/test.go

@@ -79,6 +79,17 @@ func testInvalid(t *proto.Test) {
 
 	t.Embedded.SetS("test")                              // want `avoid direct access to proto field t\.Embedded\.SetS\("test"\), use t\.GetEmbedded\(\)\.SetS\("test"\) instead`
 	t.Embedded.SetMap(map[string]string{"test": "test"}) // want `avoid direct access to proto field t\.Embedded\.SetMap\(map\[string\]string{"test": "test"}\), use t\.GetEmbedded\(\)\.SetMap\(map\[string\]string{"test": "test"}\) instead`
+
+	// Optional enum
+	switch *t.OptEnum { // want `avoid direct access to proto field \*t\.OptEnum, use t\.GetOptEnum\(\) instead`
+	case proto.Test_O_ENUM1:
+	case proto.Test_O_ENUM2:
+	}
+
+	if t.OptEnum != nil && *t.OptEnum == proto.Test_O_ENUM1 { // want `avoid direct access to proto field \*t\.OptEnum, use t\.GetOptEnum\(\) instead`
+	}
+
+	_ = *t.OptEnum // want `avoid direct access to proto field \*t\.OptEnum, use t\.GetOptEnum\(\) instead`
 }
 
 func testValid(t *proto.Test) {

testdata/test.go.golden

@@ -79,6 +79,17 @@ func testInvalid(t *proto.Test) {
 
 	t.GetEmbedded().SetS("test")                              // want `avoid direct access to proto field t\.Embedded\.SetS\("test"\), use t\.GetEmbedded\(\)\.SetS\("test"\) instead`
 	t.GetEmbedded().SetMap(map[string]string{"test": "test"}) // want `avoid direct access to proto field t\.Embedded\.SetMap\(map\[string\]string{"test": "test"}\), use t\.GetEmbedded\(\)\.SetMap\(map\[string\]string{"test": "test"}\) instead`
+
+	// Optional enum
+	switch t.GetOptEnum() { // want `avoid direct access to proto field \*t\.OptEnum, use t\.GetOptEnum\(\) instead`
+	case proto.Test_O_ENUM1:
+	case proto.Test_O_ENUM2:
+	}
+
+	if t.OptEnum != nil && t.GetOptEnum() == proto.Test_O_ENUM1 { // want `avoid direct access to proto field \*t\.OptEnum, use t\.GetOptEnum\(\) instead`
+	}
+
+	_ = t.GetOptEnum() // want `avoid direct access to proto field \*t\.OptEnum, use t\.GetOptEnum\(\) instead`
 }
 
 func testValid(t *proto.Test) {