diff --git a/lint.go b/lint.go
index 6b9fd6e..532a75a 100644
--- a/lint.go
+++ b/lint.go
@@ -198,7 +198,6 @@
 	f.lintBlankImports()
 	f.lintExported()
 	f.lintNames()
-	f.lintVarDecls()
 	f.lintElses()
 	f.lintRanges()
 	f.lintErrorf()
@@ -977,84 +976,6 @@
 	"0i":  true,
 }
 
-// lintVarDecls examines variable declarations. It complains about declarations with
-// redundant LHS types that can be inferred from the RHS.
-func (f *file) lintVarDecls() {
-	var lastGen *ast.GenDecl // last GenDecl entered.
-
-	f.walk(func(node ast.Node) bool {
-		switch v := node.(type) {
-		case *ast.GenDecl:
-			if v.Tok != token.CONST && v.Tok != token.VAR {
-				return false
-			}
-			lastGen = v
-			return true
-		case *ast.ValueSpec:
-			if lastGen.Tok == token.CONST {
-				return false
-			}
-			if len(v.Names) > 1 || v.Type == nil || len(v.Values) == 0 {
-				return false
-			}
-			rhs := v.Values[0]
-			// An underscore var appears in a common idiom for compile-time interface satisfaction,
-			// as in "var _ Interface = (*Concrete)(nil)".
-			if isIdent(v.Names[0], "_") {
-				return false
-			}
-			// If the RHS is a zero value, suggest dropping it.
-			zero := false
-			if lit, ok := rhs.(*ast.BasicLit); ok {
-				zero = zeroLiteral[lit.Value]
-			} else if isIdent(rhs, "nil") {
-				zero = true
-			}
-			if zero {
-				f.errorf(rhs, 0.9, category("zero-value"), "should drop = %s from declaration of var %s; it is the zero value", f.render(rhs), v.Names[0])
-				return false
-			}
-			lhsTyp := f.pkg.typeOf(v.Type)
-			rhsTyp := f.pkg.typeOf(rhs)
-
-			if !validType(lhsTyp) || !validType(rhsTyp) {
-				// Type checking failed (often due to missing imports).
-				return false
-			}
-
-			if !types.Identical(lhsTyp, rhsTyp) {
-				// Assignment to a different type is not redundant.
-				return false
-			}
-
-			// The next three conditions are for suppressing the warning in situations
-			// where we were unable to typecheck.
-
-			// If the LHS type is an interface, don't warn, since it is probably a
-			// concrete type on the RHS. Note that our feeble lexical check here
-			// will only pick up interface{} and other literal interface types;
-			// that covers most of the cases we care to exclude right now.
-			if _, ok := v.Type.(*ast.InterfaceType); ok {
-				return false
-			}
-			// If the RHS is an untyped const, only warn if the LHS type is its default type.
-			if defType, ok := f.isUntypedConst(rhs); ok && !isIdent(v.Type, defType) {
-				return false
-			}
-
-			f.errorf(v.Type, 0.8, category("type-inference"), "should omit type %s from declaration of var %s; it will be inferred from the right-hand side", f.render(v.Type), v.Names[0])
-			return false
-		}
-		return true
-	})
-}
-
-func validType(T types.Type) bool {
-	return T != nil &&
-		T != types.Typ[types.Invalid] &&
-		!strings.Contains(T.String(), "invalid type") // good but not foolproof
-}
-
 // lintElses examines else blocks. It complains about any else block whose if block ends in a return.
 func (f *file) lintElses() {
 	// We don't want to flag if { } else if { } else { } constructions.
diff --git a/testdata/var-decl.go b/testdata/var-decl.go
deleted file mode 100644
index 9201d18..0000000
--- a/testdata/var-decl.go
+++ /dev/null
@@ -1,86 +0,0 @@
-// Test for redundant type declaration.
-
-// Package foo ...
-package foo
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"nosuchpkg" // export data unavailable
-	"os"
-)
-
-// Q is a test type.
-type Q bool
-
-var myInt int = 7                           // MATCH /should.*int.*myInt.*inferred/
-var mux *http.ServeMux = http.NewServeMux() // MATCH /should.*\*http\.ServeMux.*inferred/
-
-var myZeroInt int = 0         // MATCH /should.*= 0.*myZeroInt.*zero value/
-var myZeroFlt float32 = 0.    // MATCH /should.*= 0\..*myZeroFlt.*zero value/
-var myZeroF64 float64 = 0.0   // MATCH /should.*= 0\..*myZeroF64.*zero value/
-var myZeroImg complex64 = 0i  // MATCH /should.*= 0i.*myZeroImg.*zero value/
-var myZeroStr string = ""     // MATCH /should.*= "".*myZeroStr.*zero value/
-var myZeroRaw string = ``     // MATCH /should.*= ``.*myZeroRaw.*zero value/
-var myZeroPtr *Q = nil        // MATCH /should.*= nil.*myZeroPtr.*zero value/
-var myZeroRune rune = '\x00'  // MATCH /should.*= '\\x00'.*myZeroRune.*zero value/
-var myZeroRune2 rune = '\000' // MATCH /should.*= '\\000'.*myZeroRune2.*zero value/
-
-// No warning because there's no type on the LHS
-var x = 0
-
-// This shouldn't get a warning because there's no initial values.
-var str fmt.Stringer
-
-// No warning because this is a const.
-const k uint64 = 7
-
-const num = 123
-
-// No warning because the var's RHS is known to be an untyped const.
-var flags uint32 = num
-
-// No warnings because the RHS is an ideal int, and the LHS is a different int type.
-var userID int64 = 1235
-var negID int64 = -1
-var parenID int64 = (17)
-var crazyID int64 = -(-(-(-9)))
-
-// Same, but for strings and floats.
-type stringT string
-type floatT float64
-
-var stringV stringT = "abc"
-var floatV floatT = 123.45
-
-// No warning because the LHS names an interface type.
-var data interface{} = googleIPs
-var googleIPs []int
-
-// No warning because it's a common idiom for interface satisfaction.
-var _ Server = (*serverImpl)(nil)
-
-// Server is a test type.
-type Server interface{}
-type serverImpl struct{}
-
-// LHS is a different type than the RHS.
-var myStringer fmt.Stringer = q(0)
-
-// LHS is a different type than the RHS.
-var out io.Writer = os.Stdout
-
-var out2 io.Writer = newWriter() // MATCH /should omit.*io\.Writer/
-
-func newWriter() io.Writer { return nil }
-
-// We don't figure out the true types of LHS and RHS here,
-// so we suppress the check.
-var ni nosuchpkg.Interface = nosuchpkg.NewConcrete()
-
-var y string = q(1).String() // MATCH /should.*string/
-
-type q int
-
-func (q) String() string { return "I'm a q" }