code review 163740043: go/types: don't mark external package objects as used

go/types/resolver.go

 // Copyright 2013 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package types
 
 import (
         "errors"
         "fmt"
         "go/ast"
@@ skipping 95 matching lines @@
         if ident.Name == "init" {
                 check.errorf(ident.Pos(), "cannot declare init - must be func")
                 return
         }
 
         check.declare(check.pkg.scope, ident, obj)
         check.objMap[obj] = d
         obj.setOrder(uint32(len(check.objMap)))
 }
 
-// filename returns a file name suitable for debugging for the given file.
+// filename returns a filename suitable for debugging output.
 func (check *Checker) filename(fileNo int) string {
         file := check.files[fileNo]
         if pos := file.Pos(); pos.IsValid() {
                 return check.fset.File(pos).Name()
         }
         return fmt.Sprintf("file[%d]", fileNo)
 }
 
 // collectObjects collects all file and package objects and inserts them
 // into their respective scopes. It also performs imports and associates
@@ skipping 100 matching lines @@
                                                                         // (We must not modify their existing position
                                                                         // information because the same package - found
                                                                         // via Config.Packages - may be dot-imported in
                                                                         // another package!)
                                                                         check.declare(fileScope, nil, obj)
                                                                         check.recordImplicit(s, obj)
                                                                 }
                                                         }
                                                         // add position to set of dot-import positions for this file
                                                         // (this is only needed for "imported but not used" errors)
-                                                        check.addUnusedDotImport(fileNo, imp, s.Pos())
+                                                        check.addUnusedDotImport(fileScope, imp, s.Pos())
                                                 } else {
                                                         // declare imported package object in file scope
                                                         check.declare(fileScope, nil, obj)
                                                 }
 
                                         case *ast.ValueSpec:
                                                 switch d.Tok {
                                                 case token.CONST:
                                                         // determine which initialization expressions to use
                                                         switch {
@@ skipping 158 matching lines @@
 // unusedImports checks for unused imports.
 func (check *Checker) unusedImports() {
         // if function bodies are not checked, packages' uses are likely missing - don't check
         if check.conf.IgnoreFuncBodies {
                 return
         }
 
         // spec: "It is illegal (...) to directly import a package without referring to
         // any of its exported identifiers. To import a package solely for its side-effects
         // (initialization), use the blank identifier as explicit package name."
+
+        // check use of regular imported packages
         for _, scope := range check.pkg.scope.children /* file scopes */ {
                 for _, obj := range scope.elems {
                         if obj, ok := obj.(*PkgName); ok {
                                 // Unused "blank imports" are automatically ignored
                                 // since _ identifiers are not entered into scopes.
                                 if !obj.used {
                                         path := obj.imported.path
                                         base := pathLib.Base(path)
                                         if obj.name == base {
                                                 check.softErrorf(obj.pos, "%q imported but not used", path)
                                         } else {
                                                 check.softErrorf(obj.pos, "%q imported but not used as %s", path, obj.name)
                                         }
                                 }
                         }
                 }
         }
 
+        // check use of dot-imported packages
         for _, unusedDotImports := range check.unusedDotImports {
                 for pkg, pos := range unusedDotImports {
                         check.softErrorf(pos, "%q imported but not used", pkg.path)
                 }
         }
 }