...
Run Format

Source file src/go/ast/resolve.go

Documentation: go/ast

  // Copyright 2011 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.
  
  // This file implements NewPackage.
  
  package ast
  
  import (
  	"fmt"
  	"go/scanner"
  	"go/token"
  	"strconv"
  )
  
  type pkgBuilder struct {
  	fset   *token.FileSet
  	errors scanner.ErrorList
  }
  
  func (p *pkgBuilder) error(pos token.Pos, msg string) {
  	p.errors.Add(p.fset.Position(pos), msg)
  }
  
  func (p *pkgBuilder) errorf(pos token.Pos, format string, args ...interface{}) {
  	p.error(pos, fmt.Sprintf(format, args...))
  }
  
  func (p *pkgBuilder) declare(scope, altScope *Scope, obj *Object) {
  	alt := scope.Insert(obj)
  	if alt == nil && altScope != nil {
  		// see if there is a conflicting declaration in altScope
  		alt = altScope.Lookup(obj.Name)
  	}
  	if alt != nil {
  		prevDecl := ""
  		if pos := alt.Pos(); pos.IsValid() {
  			prevDecl = fmt.Sprintf("\n\tprevious declaration at %s", p.fset.Position(pos))
  		}
  		p.error(obj.Pos(), fmt.Sprintf("%s redeclared in this block%s", obj.Name, prevDecl))
  	}
  }
  
  func resolve(scope *Scope, ident *Ident) bool {
  	for ; scope != nil; scope = scope.Outer {
  		if obj := scope.Lookup(ident.Name); obj != nil {
  			ident.Obj = obj
  			return true
  		}
  	}
  	return false
  }
  
  // An Importer resolves import paths to package Objects.
  // The imports map records the packages already imported,
  // indexed by package id (canonical import path).
  // An Importer must determine the canonical import path and
  // check the map to see if it is already present in the imports map.
  // If so, the Importer can return the map entry. Otherwise, the
  // Importer should load the package data for the given path into
  // a new *Object (pkg), record pkg in the imports map, and then
  // return pkg.
  type Importer func(imports map[string]*Object, path string) (pkg *Object, err error)
  
  // NewPackage creates a new Package node from a set of File nodes. It resolves
  // unresolved identifiers across files and updates each file's Unresolved list
  // accordingly. If a non-nil importer and universe scope are provided, they are
  // used to resolve identifiers not declared in any of the package files. Any
  // remaining unresolved identifiers are reported as undeclared. If the files
  // belong to different packages, one package name is selected and files with
  // different package names are reported and then ignored.
  // The result is a package node and a scanner.ErrorList if there were errors.
  //
  func NewPackage(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error) {
  	var p pkgBuilder
  	p.fset = fset
  
  	// complete package scope
  	pkgName := ""
  	pkgScope := NewScope(universe)
  	for _, file := range files {
  		// package names must match
  		switch name := file.Name.Name; {
  		case pkgName == "":
  			pkgName = name
  		case name != pkgName:
  			p.errorf(file.Package, "package %s; expected %s", name, pkgName)
  			continue // ignore this file
  		}
  
  		// collect top-level file objects in package scope
  		for _, obj := range file.Scope.Objects {
  			p.declare(pkgScope, nil, obj)
  		}
  	}
  
  	// package global mapping of imported package ids to package objects
  	imports := make(map[string]*Object)
  
  	// complete file scopes with imports and resolve identifiers
  	for _, file := range files {
  		// ignore file if it belongs to a different package
  		// (error has already been reported)
  		if file.Name.Name != pkgName {
  			continue
  		}
  
  		// build file scope by processing all imports
  		importErrors := false
  		fileScope := NewScope(pkgScope)
  		for _, spec := range file.Imports {
  			if importer == nil {
  				importErrors = true
  				continue
  			}
  			path, _ := strconv.Unquote(spec.Path.Value)
  			pkg, err := importer(imports, path)
  			if err != nil {
  				p.errorf(spec.Path.Pos(), "could not import %s (%s)", path, err)
  				importErrors = true
  				continue
  			}
  			// TODO(gri) If a local package name != "." is provided,
  			// global identifier resolution could proceed even if the
  			// import failed. Consider adjusting the logic here a bit.
  
  			// local name overrides imported package name
  			name := pkg.Name
  			if spec.Name != nil {
  				name = spec.Name.Name
  			}
  
  			// add import to file scope
  			if name == "." {
  				// merge imported scope with file scope
  				for _, obj := range pkg.Data.(*Scope).Objects {
  					p.declare(fileScope, pkgScope, obj)
  				}
  			} else if name != "_" {
  				// declare imported package object in file scope
  				// (do not re-use pkg in the file scope but create
  				// a new object instead; the Decl field is different
  				// for different files)
  				obj := NewObj(Pkg, name)
  				obj.Decl = spec
  				obj.Data = pkg.Data
  				p.declare(fileScope, pkgScope, obj)
  			}
  		}
  
  		// resolve identifiers
  		if importErrors {
  			// don't use the universe scope without correct imports
  			// (objects in the universe may be shadowed by imports;
  			// with missing imports, identifiers might get resolved
  			// incorrectly to universe objects)
  			pkgScope.Outer = nil
  		}
  		i := 0
  		for _, ident := range file.Unresolved {
  			if !resolve(fileScope, ident) {
  				p.errorf(ident.Pos(), "undeclared name: %s", ident.Name)
  				file.Unresolved[i] = ident
  				i++
  			}
  
  		}
  		file.Unresolved = file.Unresolved[0:i]
  		pkgScope.Outer = universe // reset universe scope
  	}
  
  	p.errors.Sort()
  	return &Package{pkgName, pkgScope, imports, files}, p.errors.Err()
  }
  

View as plain text