// 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 (
	
	
	
	
)

// Eval returns the type and, if constant, the value for the
// expression expr, evaluated at position pos of package pkg,
// which must have been derived from type-checking an AST with
// complete position information relative to the provided file
// set.
//
// The meaning of the parameters fset, pkg, and pos is the
// same as in CheckExpr. An error is returned if expr cannot
// be parsed successfully, or the resulting expr AST cannot be
// type-checked.
func ( *token.FileSet,  *Package,  token.Pos,  string) ( TypeAndValue,  error) {
	// parse expressions
	,  := parser.ParseExprFrom(, "eval", , 0)
	if  != nil {
		return TypeAndValue{}, 
	}

	 := &Info{
		Types: make(map[ast.Expr]TypeAndValue),
	}
	 = CheckExpr(, , , , )
	return .Types[], 
}

// CheckExpr type checks the expression expr as if it had appeared at
// position pos of package pkg. Type information about the expression
// is recorded in info.
//
// If pkg == nil, the Universe scope is used and the provided
// position pos is ignored. If pkg != nil, and pos is invalid,
// the package scope is used. Otherwise, pos must belong to the
// package.
//
// An error is returned if pos is not within the package or
// if the node cannot be type-checked.
//
// Note: Eval and CheckExpr should not be used instead of running Check
// to compute types and values, but in addition to Check, as these
// functions ignore the context in which an expression is used (e.g., an
// assignment). Thus, top-level untyped constants will return an
// untyped type rather then the respective context-specific type.
//
func ( *token.FileSet,  *Package,  token.Pos,  ast.Expr,  *Info) ( error) {
	// determine scope
	var  *Scope
	if  == nil {
		 = Universe
		 = token.NoPos
	} else if !.IsValid() {
		 = .scope
	} else {
		// The package scope extent (position information) may be
		// incorrect (files spread across a wide range of fset
		// positions) - ignore it and just consider its children
		// (file scopes).
		for ,  := range .scope.children {
			if  = .Innermost();  != nil {
				break
			}
		}
		if  == nil || debug {
			 := 
			for  != nil &&  != .scope {
				 = .parent
			}
			// s == nil || s == pkg.scope
			if  == nil {
				return fmt.Errorf("no position %s found in package %s", .Position(), .name)
			}
		}
	}

	// initialize checker
	 := NewChecker(nil, , , )
	.scope = 
	.pos = 
	defer .handleBailout(&)

	// evaluate node
	var  operand
	.rawExpr(&, , nil)
	.processDelayed(0) // incl. all functions
	.recordUntyped()

	return nil
}