add new rule time equal

config/config.go

@@ -81,6 +81,7 @@ var allRules = append([]lint.Rule{
 	&rule.NestedStructs{},
 	&rule.IfReturnRule{},
 	&rule.UselessBreak{},
+	&rule.TimeEqualRule{},
 }, defaultRules...)
 
 var allFormatters = []lint.Formatter{

rule/time-equal.go

@@ -0,0 +1,70 @@
+package rule
+
+import (
+	"fmt"
+	"go/ast"
+	"go/token"
+
+	"github.com/mgechev/revive/lint"
+)
+
+// TimeEqualRule shows where "==" and "!=" used for equality check time.Time
+type TimeEqualRule struct{}
+
+// Apply applies the rule to given file.
+func (*TimeEqualRule) Apply(file *lint.File, _ lint.Arguments) []lint.Failure {
+	var failures []lint.Failure
+
+	onFailure := func(failure lint.Failure) {
+		failures = append(failures, failure)
+	}
+
+	w := &lintTimeEqual{file, onFailure}
+	w.file.Pkg.TypeCheck()
+
+	ast.Walk(w, file.AST)
+	return failures
+}
+
+// Name returns the rule name.
+func (*TimeEqualRule) Name() string {
+	return "time-equal"
+}
+
+type lintTimeEqual struct {
+	file      *lint.File
+	onFailure func(lint.Failure)
+}
+
+func (l *lintTimeEqual) Visit(node ast.Node) ast.Visitor {
+	expr, ok := node.(*ast.BinaryExpr)
+	if !ok {
+		return l
+	}
+
+	xtyp := l.file.Pkg.TypeOf(expr.X)
+	ytyp := l.file.Pkg.TypeOf(expr.Y)
+
+	if !isNamedType(xtyp, "time", "Time") || !isNamedType(ytyp, "time", "Time") {
+		return l
+	}
+
+	var failure string
+	switch expr.Op {
+	case token.EQL:
+		failure = fmt.Sprintf("use %s.Equal(%s) instead of %q operator", expr.X, expr.Y, expr.Op)
+	case token.NEQ:
+		failure = fmt.Sprintf("use !%s.Equal(%s) instead of %q operator", expr.X, expr.Y, expr.Op)
+	default:
+		return l
+	}
+
+	l.onFailure(lint.Failure{
+		Category:   "time",
+		Confidence: 1,
+		Node:       node,
+		Failure:    failure,
+	})
+
+	return l
+}

test/time-equal_test.go

@@ -0,0 +1,12 @@
+package test
+
+import (
+	"testing"
+
+	"github.com/mgechev/revive/rule"
+)
+
+// TestTimeEqual rule.
+func TestTimeEqual(t *testing.T) {
+	testRule(t, "time-equal", &rule.TimeEqualRule{})
+}

testdata/time-equal.go

@@ -0,0 +1,27 @@
+package pkg
+
+import "time"
+
+func eqlOp() bool {
+	t := time.Now()
+	u := t
+	return t == u // MATCH /use t.Equal(u) instead of "==" operator/
+}
+
+func eqlFun() bool {
+	t := time.Now()
+	u := t
+	return t.Equal(t)
+}
+
+func neqlOp() bool {
+	t := time.Now()
+	u := t.Add(2 * time.Second)
+	return t != u // MATCH /use !t.Equal(u) instead of "!=" operator/
+}
+
+func neqlFun() bool {
+	t := time.Now()
+	u := t.Sub(2 * time.Second)
+	return !t.Equal(t)
+}