diff --git a/README b/README
index c763bdd..81d1f83 100644
--- a/README
+++ b/README
@@ -3,7 +3,7 @@
 To install, run
   go get github.com/golang/lint/golint
 
-Invoke golint with one or more filenames or directories.
+Invoke golint with one or more filenames, a directory, or a package name.
 The output of this tool is a list of suggestions in Vim quickfix format,
 which is accepted by lots of different editors.
 
diff --git a/golint/golint.go b/golint/golint.go
index c5fd1e7..318c061 100644
--- a/golint/golint.go
+++ b/golint/golint.go
@@ -10,25 +10,44 @@
 import (
 	"flag"
 	"fmt"
+	"go/build"
 	"io/ioutil"
 	"os"
 	"path/filepath"
-	"strings"
 
 	"github.com/golang/lint"
 )
 
 var minConfidence = flag.Float64("min_confidence", 0.8, "minimum confidence of a problem to print it")
 
+func usage() {
+	fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
+	fmt.Fprintf(os.Stderr, "\tgolint [flags] # runs on package in current directory\n")
+	fmt.Fprintf(os.Stderr, "\tgolint [flags] package\n")
+	fmt.Fprintf(os.Stderr, "\tgolint [flags] directory\n")
+	fmt.Fprintf(os.Stderr, "\tgolint [flags] files... # must be a single package\n")
+	fmt.Fprintf(os.Stderr, "Flags:\n")
+	flag.PrintDefaults()
+}
+
 func main() {
+	flag.Usage = usage
 	flag.Parse()
 
-	for _, filename := range flag.Args() {
-		if isDir(filename) {
-			lintDir(filename)
+	switch flag.NArg() {
+	case 0:
+		lintDir(".")
+	case 1:
+		arg := flag.Arg(0)
+		if isDir(arg) {
+			lintDir(arg)
+		} else if exists(arg) {
+			lintFiles(arg)
 		} else {
-			lintFile(filename)
+			lintPackage(arg)
 		}
+	default:
+		lintFiles(flag.Args()...)
 	}
 }
 
@@ -37,31 +56,64 @@
 	return err == nil && fi.IsDir()
 }
 
-func lintFile(filename string) {
-	src, err := ioutil.ReadFile(filename)
-	if err != nil {
-		fmt.Fprintln(os.Stderr, err)
-		return
+func exists(filename string) bool {
+	_, err := os.Stat(filename)
+	return err == nil
+}
+
+func lintFiles(filenames ...string) {
+	files := make(map[string][]byte)
+	for _, filename := range filenames {
+		src, err := ioutil.ReadFile(filename)
+		if err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			continue
+		}
+		files[filename] = src
 	}
 
 	l := new(lint.Linter)
-	ps, err := l.Lint(filename, src)
+	ps, err := l.LintFiles(files)
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "%v:%v\n", filename, err)
+		fmt.Fprintf(os.Stderr, "%v\n", err)
 		return
 	}
 	for _, p := range ps {
 		if p.Confidence >= *minConfidence {
-			fmt.Printf("%s:%v: %s\n", filename, p.Position, p.Text)
+			fmt.Printf("%v: %s\n", p.Position, p.Text)
 		}
 	}
 }
 
 func lintDir(dirname string) {
-	filepath.Walk(dirname, func(path string, info os.FileInfo, err error) error {
-		if err == nil && !info.IsDir() && strings.HasSuffix(path, ".go") {
-			lintFile(path)
+	pkg, err := build.ImportDir(dirname, 0)
+	lintImportedPackage(pkg, err)
+}
+
+func lintPackage(pkgname string) {
+	pkg, err := build.Import(pkgname, "", 0)
+	lintImportedPackage(pkg, err)
+}
+
+func lintImportedPackage(pkg *build.Package, err error) {
+	if err != nil {
+		if _, nogo := err.(*build.NoGoError); nogo {
+			// Don't complain if the failure is due to no Go source files.
+			return
 		}
-		return err
-	})
+		fmt.Fprintln(os.Stderr, err)
+		return
+	}
+
+	var files []string
+	files = append(files, pkg.GoFiles...)
+	files = append(files, pkg.TestGoFiles...)
+	if pkg.Dir != "." {
+		for i, f := range files {
+			files[i] = filepath.Join(pkg.Dir, f)
+		}
+	}
+	// TODO(dsymonds): Do foo_test too (pkg.XTestGoFiles)
+
+	lintFiles(files...)
 }
diff --git a/lint.go b/lint.go
index 2829be5..bfff95c 100644
--- a/lint.go
+++ b/lint.go
@@ -49,39 +49,57 @@
 
 // Lint lints src.
 func (l *Linter) Lint(filename string, src []byte) ([]Problem, error) {
-	fset := token.NewFileSet()
-	f, err := parser.ParseFile(fset, "", src, parser.ParseComments)
-	if err != nil {
-		return nil, err
-	}
-	return (&file{fset: fset, f: f, src: src, filename: filename}).lint(), nil
+	return l.LintFiles(map[string][]byte{filename: src})
 }
 
-// file represents a file being linted.
-type file struct {
-	fset     *token.FileSet
-	f        *ast.File
-	src      []byte
-	filename string
+// LintFiles lints a set of files.
+// The argument is a map of filename to source.
+func (l *Linter) LintFiles(files map[string][]byte) ([]Problem, error) {
+	if len(files) == 0 {
+		return nil, nil
+	}
+	pkg := &pkg{
+		fset:  token.NewFileSet(),
+		files: make(map[string]*file),
+	}
+	for filename, src := range files {
+		f, err := parser.ParseFile(pkg.fset, filename, src, parser.ParseComments)
+		if err != nil {
+			return nil, err
+		}
+		// TODO(dsymonds): Check for package name mismatch.
+		pkg.files[filename] = &file{
+			pkg:      pkg,
+			f:        f,
+			fset:     pkg.fset,
+			src:      src,
+			filename: filename,
+		}
+	}
+	return pkg.lint(), nil
+}
+
+// pkg represents a package being linted.
+type pkg struct {
+	fset  *token.FileSet
+	files map[string]*file
 
 	typesPkg  *types.Package
 	typesInfo *types.Info
 
-	// sortable is the set of types in the file that implement sort.Interface.
+	// sortable is the set of types in the package that implement sort.Interface.
 	sortable map[string]bool
-	// main is whether this file is in a "main" package.
+	// main is whether this is a "main" package.
 	main bool
 
 	problems []Problem
 }
 
-func (f *file) isTest() bool { return strings.HasSuffix(f.filename, "_test.go") }
-
-func (f *file) lint() []Problem {
-	if err := f.typeCheck(); err != nil {
+func (p *pkg) lint() []Problem {
+	if err := p.typeCheck(); err != nil {
 		/* TODO(dsymonds): Consider reporting these errors when golint operates on entire packages.
 		if e, ok := err.(types.Error); ok {
-			p := f.fset.Position(e.Pos)
+			pos := p.fset.Position(e.Pos)
 			conf := 1.0
 			if strings.Contains(e.Msg, "can't find import: ") {
 				// Golint is probably being run in a context that doesn't support
@@ -89,7 +107,7 @@
 				conf = 0
 			}
 			if conf > 0 {
-				f.errorfAt(p, conf, category("typechecking"), e.Msg)
+				p.errorfAt(pos, conf, category("typechecking"), e.Msg)
 			}
 
 			// TODO(dsymonds): Abort if !e.Soft?
@@ -97,9 +115,28 @@
 		*/
 	}
 
-	f.scanSortable()
-	f.main = f.isMain()
+	p.scanSortable()
+	p.main = p.isMain()
 
+	for _, f := range p.files {
+		f.lint()
+	}
+	// TODO(dsymonds): sort?
+	return p.problems
+}
+
+// file represents a file being linted.
+type file struct {
+	pkg      *pkg
+	f        *ast.File
+	fset     *token.FileSet
+	src      []byte
+	filename string
+}
+
+func (f *file) isTest() bool { return strings.HasSuffix(f.filename, "_test.go") }
+
+func (f *file) lint() {
 	f.lintPackageComment()
 	f.lintImports()
 	f.lintBlankImports()
@@ -115,8 +152,6 @@
 	f.lintIncDec()
 	f.lintMake()
 	f.lintErrorReturn()
-
-	return f.problems
 }
 
 type link string
@@ -125,15 +160,20 @@
 // The variadic arguments may start with link and category types,
 // and must end with a format string and any arguments.
 func (f *file) errorf(n ast.Node, confidence float64, args ...interface{}) {
-	p := f.fset.Position(n.Pos())
-	f.errorfAt(p, confidence, args...)
+	pos := f.fset.Position(n.Pos())
+	if pos.Filename == "" {
+		pos.Filename = f.filename
+	}
+	f.pkg.errorfAt(pos, confidence, args...)
 }
 
-func (f *file) errorfAt(p token.Position, confidence float64, args ...interface{}) {
+func (p *pkg) errorfAt(pos token.Position, confidence float64, args ...interface{}) {
 	problem := Problem{
-		Position:   p,
+		Position:   pos,
 		Confidence: confidence,
-		LineText:   srcLine(f.src, p),
+	}
+	if pos.Filename != "" {
+		problem.LineText = srcLine(p.files[pos.Filename].src, pos)
 	}
 
 argLoop:
@@ -151,12 +191,12 @@
 
 	problem.Text = fmt.Sprintf(args[0].(string), args[1:]...)
 
-	f.problems = append(f.problems, problem)
+	p.problems = append(p.problems, problem)
 }
 
 var gcImporter = gcimporter.Import
 
-func (f *file) typeCheck() error {
+func (p *pkg) typeCheck() error {
 	// Do typechecking without errors so we do as much as possible.
 	config := &types.Config{
 		Import: gcImporter,
@@ -166,24 +206,30 @@
 		Defs:  make(map[*ast.Ident]types.Object),
 		Uses:  make(map[*ast.Ident]types.Object),
 	}
-	pkg, err := config.Check(f.f.Name.Name, f.fset, []*ast.File{f.f}, info)
+	var anyFile *file
+	var astFiles []*ast.File
+	for _, f := range p.files {
+		anyFile = f
+		astFiles = append(astFiles, f.f)
+	}
+	pkg, err := config.Check(anyFile.f.Name.Name, p.fset, astFiles, info)
 	if err != nil {
 		return err
 	}
-	f.typesPkg = pkg
-	f.typesInfo = info
+	p.typesPkg = pkg
+	p.typesInfo = info
 	return err
 }
 
-func (f *file) typeOf(expr ast.Expr) types.Type {
-	if f.typesInfo == nil {
+func (p *pkg) typeOf(expr ast.Expr) types.Type {
+	if p.typesInfo == nil {
 		return nil
 	}
-	return f.typesInfo.TypeOf(expr)
+	return p.typesInfo.TypeOf(expr)
 }
 
-func (f *file) scanSortable() {
-	f.sortable = make(map[string]bool)
+func (p *pkg) scanSortable() {
+	p.sortable = make(map[string]bool)
 
 	// bitfield for which methods exist on each type.
 	const (
@@ -193,25 +239,36 @@
 	)
 	nmap := map[string]int{"Len": Len, "Less": Less, "Swap": Swap}
 	has := make(map[string]int)
-	f.walk(func(n ast.Node) bool {
-		fn, ok := n.(*ast.FuncDecl)
-		if !ok || fn.Recv == nil {
-			return true
-		}
-		// TODO(dsymonds): We could check the signature to be more precise.
-		recv := receiverType(fn)
-		if i, ok := nmap[fn.Name.Name]; ok {
-			has[recv] |= i
-		}
-		return false
-	})
+	for _, f := range p.files {
+		f.walk(func(n ast.Node) bool {
+			fn, ok := n.(*ast.FuncDecl)
+			if !ok || fn.Recv == nil {
+				return true
+			}
+			// TODO(dsymonds): We could check the signature to be more precise.
+			recv := receiverType(fn)
+			if i, ok := nmap[fn.Name.Name]; ok {
+				has[recv] |= i
+			}
+			return false
+		})
+	}
 	for typ, ms := range has {
 		if ms == Len|Less|Swap {
-			f.sortable[typ] = true
+			p.sortable[typ] = true
 		}
 	}
 }
 
+func (p *pkg) isMain() bool {
+	for _, f := range p.files {
+		if f.isMain() {
+			return true
+		}
+	}
+	return false
+}
+
 func (f *file) isMain() bool {
 	if f.f.Name.Name == "main" {
 		return true
@@ -250,7 +307,7 @@
 // not documented.
 func (f *file) lintBlankImports() {
 	// In package main and in tests, we don't complain about blank imports.
-	if f.main || f.isTest() {
+	if f.pkg.main || f.isTest() {
 		return
 	}
 
@@ -626,7 +683,7 @@
 		}
 		switch name {
 		case "Len", "Less", "Swap":
-			if f.sortable[recv] {
+			if f.pkg.sortable[recv] {
 				return
 			}
 		}
@@ -764,8 +821,8 @@
 				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.typeOf(v.Type)
-			rhsTyp := f.typeOf(rhs)
+			lhsTyp := f.pkg.typeOf(v.Type)
+			rhsTyp := f.pkg.typeOf(rhs)
 			if lhsTyp != nil && rhsTyp != nil && !types.Identical(lhsTyp, rhsTyp) {
 				// Assignment to a different type is not redundant.
 				return false