resolve.go

Documentation: go/ast

		 1  // Copyright 2011 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  // This file implements NewPackage.
		 6  
		 7  package ast
		 8  
		 9  import (
		10  	"fmt"
		11  	"go/scanner"
		12  	"go/token"
		13  	"strconv"
		14  )
		15  
		16  type pkgBuilder struct {
		17  	fset	 *token.FileSet
		18  	errors scanner.ErrorList
		19  }
		20  
		21  func (p *pkgBuilder) error(pos token.Pos, msg string) {
		22  	p.errors.Add(p.fset.Position(pos), msg)
		23  }
		24  
		25  func (p *pkgBuilder) errorf(pos token.Pos, format string, args ...interface{}) {
		26  	p.error(pos, fmt.Sprintf(format, args...))
		27  }
		28  
		29  func (p *pkgBuilder) declare(scope, altScope *Scope, obj *Object) {
		30  	alt := scope.Insert(obj)
		31  	if alt == nil && altScope != nil {
		32  		// see if there is a conflicting declaration in altScope
		33  		alt = altScope.Lookup(obj.Name)
		34  	}
		35  	if alt != nil {
		36  		prevDecl := ""
		37  		if pos := alt.Pos(); pos.IsValid() {
		38  			prevDecl = fmt.Sprintf("\n\tprevious declaration at %s", p.fset.Position(pos))
		39  		}
		40  		p.error(obj.Pos(), fmt.Sprintf("%s redeclared in this block%s", obj.Name, prevDecl))
		41  	}
		42  }
		43  
		44  func resolve(scope *Scope, ident *Ident) bool {
		45  	for ; scope != nil; scope = scope.Outer {
		46  		if obj := scope.Lookup(ident.Name); obj != nil {
		47  			ident.Obj = obj
		48  			return true
		49  		}
		50  	}
		51  	return false
		52  }
		53  
		54  // An Importer resolves import paths to package Objects.
		55  // The imports map records the packages already imported,
		56  // indexed by package id (canonical import path).
		57  // An Importer must determine the canonical import path and
		58  // check the map to see if it is already present in the imports map.
		59  // If so, the Importer can return the map entry. Otherwise, the
		60  // Importer should load the package data for the given path into
		61  // a new *Object (pkg), record pkg in the imports map, and then
		62  // return pkg.
		63  type Importer func(imports map[string]*Object, path string) (pkg *Object, err error)
		64  
		65  // NewPackage creates a new Package node from a set of File nodes. It resolves
		66  // unresolved identifiers across files and updates each file's Unresolved list
		67  // accordingly. If a non-nil importer and universe scope are provided, they are
		68  // used to resolve identifiers not declared in any of the package files. Any
		69  // remaining unresolved identifiers are reported as undeclared. If the files
		70  // belong to different packages, one package name is selected and files with
		71  // different package names are reported and then ignored.
		72  // The result is a package node and a scanner.ErrorList if there were errors.
		73  //
		74  func NewPackage(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error) {
		75  	var p pkgBuilder
		76  	p.fset = fset
		77  
		78  	// complete package scope
		79  	pkgName := ""
		80  	pkgScope := NewScope(universe)
		81  	for _, file := range files {
		82  		// package names must match
		83  		switch name := file.Name.Name; {
		84  		case pkgName == "":
		85  			pkgName = name
		86  		case name != pkgName:
		87  			p.errorf(file.Package, "package %s; expected %s", name, pkgName)
		88  			continue // ignore this file
		89  		}
		90  
		91  		// collect top-level file objects in package scope
		92  		for _, obj := range file.Scope.Objects {
		93  			p.declare(pkgScope, nil, obj)
		94  		}
		95  	}
		96  
		97  	// package global mapping of imported package ids to package objects
		98  	imports := make(map[string]*Object)
		99  
	 100  	// complete file scopes with imports and resolve identifiers
	 101  	for _, file := range files {
	 102  		// ignore file if it belongs to a different package
	 103  		// (error has already been reported)
	 104  		if file.Name.Name != pkgName {
	 105  			continue
	 106  		}
	 107  
	 108  		// build file scope by processing all imports
	 109  		importErrors := false
	 110  		fileScope := NewScope(pkgScope)
	 111  		for _, spec := range file.Imports {
	 112  			if importer == nil {
	 113  				importErrors = true
	 114  				continue
	 115  			}
	 116  			path, _ := strconv.Unquote(spec.Path.Value)
	 117  			pkg, err := importer(imports, path)
	 118  			if err != nil {
	 119  				p.errorf(spec.Path.Pos(), "could not import %s (%s)", path, err)
	 120  				importErrors = true
	 121  				continue
	 122  			}
	 123  			// TODO(gri) If a local package name != "." is provided,
	 124  			// global identifier resolution could proceed even if the
	 125  			// import failed. Consider adjusting the logic here a bit.
	 126  
	 127  			// local name overrides imported package name
	 128  			name := pkg.Name
	 129  			if spec.Name != nil {
	 130  				name = spec.Name.Name
	 131  			}
	 132  
	 133  			// add import to file scope
	 134  			if name == "." {
	 135  				// merge imported scope with file scope
	 136  				for _, obj := range pkg.Data.(*Scope).Objects {
	 137  					p.declare(fileScope, pkgScope, obj)
	 138  				}
	 139  			} else if name != "_" {
	 140  				// declare imported package object in file scope
	 141  				// (do not re-use pkg in the file scope but create
	 142  				// a new object instead; the Decl field is different
	 143  				// for different files)
	 144  				obj := NewObj(Pkg, name)
	 145  				obj.Decl = spec
	 146  				obj.Data = pkg.Data
	 147  				p.declare(fileScope, pkgScope, obj)
	 148  			}
	 149  		}
	 150  
	 151  		// resolve identifiers
	 152  		if importErrors {
	 153  			// don't use the universe scope without correct imports
	 154  			// (objects in the universe may be shadowed by imports;
	 155  			// with missing imports, identifiers might get resolved
	 156  			// incorrectly to universe objects)
	 157  			pkgScope.Outer = nil
	 158  		}
	 159  		i := 0
	 160  		for _, ident := range file.Unresolved {
	 161  			if !resolve(fileScope, ident) {
	 162  				p.errorf(ident.Pos(), "undeclared name: %s", ident.Name)
	 163  				file.Unresolved[i] = ident
	 164  				i++
	 165  			}
	 166  
	 167  		}
	 168  		file.Unresolved = file.Unresolved[0:i]
	 169  		pkgScope.Outer = universe // reset universe scope
	 170  	}
	 171  
	 172  	p.errors.Sort()
	 173  	return &Package{pkgName, pkgScope, imports, files}, p.errors.Err()
	 174  }
	 175
View as plain text