Documentation
¶
Index ¶
- Constants
- func CheckExpr(fset *token.FileSet, pkg *types.Package, pos token.Pos, expr ast.Expr, ...) (err error)
- func CorrectTypesInfo[Ident astIdent](scope *types.Scope, objMap objMapT, uses map[Ident]types.Object)
- func DeleteObjects(scope *types.Scope, files []*goast.File) objMapT
- func ExprString(x ast.Expr) string
- func SetDebug(flags dbgFlags)
- func WriteExpr(buf *bytes.Buffer, x ast.Expr)
- type CheckConfig
- type Checker
- type Config
- type Info
- type Project
Constants ¶
const ( DbgFlagVerbose dbgFlags = 1 << iota DbgFlagPrintError DbgFlagDisableRecover DbgFlagDefault = DbgFlagVerbose | DbgFlagPrintError DbgFlagAll = DbgFlagDefault | DbgFlagDisableRecover )
Variables ¶
This section is empty.
Functions ¶
func CheckExpr ¶
func CheckExpr(fset *token.FileSet, pkg *types.Package, pos token.Pos, expr ast.Expr, info *Info) (err error)
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. The expression may be an identifier denoting an uninstantiated generic function or type.
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 than the respective context-specific type.
func CorrectTypesInfo ¶ added in v1.1.10
func CorrectTypesInfo[Ident astIdent](scope *types.Scope, objMap objMapT, uses map[Ident]types.Object)
CorrectTypesInfo corrects types info to avoid there are two instances for the same Go object.
func DeleteObjects ¶ added in v1.1.10
DeleteObjects deletes all objects defined in Go files and returns deleted objects.
func ExprString ¶ added in v1.1.10
ExprString returns the (possibly shortened) string representation for x. Shortened representations are suitable for user interfaces but may not necessarily follow Go syntax.
Types ¶
type CheckConfig ¶ added in v1.1.10
A CheckConfig specifies the configuration for type checking. The zero value for Config is a ready-to-use default configuration.
func (*CheckConfig) Check ¶ added in v1.1.10
func (conf *CheckConfig) Check(path string, fset *token.FileSet, files []*ast.File, info *Info) (ret *types.Package, err error)
Check type-checks a package and returns the resulting package object and the first error if any. Additionally, if info != nil, Check populates each of the non-nil maps in the Info struct.
The package is marked as complete if no errors occurred, otherwise it is incomplete. See Config.Error for controlling behavior in the presence of errors.
The package is specified by a list of *ast.Files and corresponding file set, and the package path the package is identified with. The clean path must not be empty or dot (".").
type Checker ¶
type Checker struct {
// contains filtered or unexported fields
}
A Checker maintains the state of the type checker. It must be created with NewChecker.
func NewChecker ¶
NewChecker returns a new Checker instance for a given package. Package files may be added incrementally via checker.Files.
type Config ¶
type Config struct {
// Types provides type information for the package (required).
Types *types.Package
// Fset provides source position information for syntax trees and types (required).
Fset *token.FileSet
// WorkingDir is the directory in which to run gop compiler (optional).
// If WorkingDir is not set, os.Getwd() is used.
WorkingDir string
// C2goBase specifies base of standard c2go packages (optional).
// Default is github.com/goplus/.
C2goBase string
// Mod represents a gop.mod object (optional).
Mod *gopmod.Module
}
type Info ¶
type Info struct {
// Types maps expressions to their types, and for constant
// expressions, also their values. Invalid expressions are
// omitted.
//
// For (possibly parenthesized) identifiers denoting built-in
// functions, the recorded signatures are call-site specific:
// if the call result is not a constant, the recorded type is
// an argument-specific signature. Otherwise, the recorded type
// is invalid.
//
// The Types map does not record the type of every identifier,
// only those that appear where an arbitrary expression is
// permitted. For instance, the identifier f in a selector
// expression x.f is found only in the Selections map, the
// identifier z in a variable declaration 'var z int' is found
// only in the Defs map, and identifiers denoting packages in
// qualified identifiers are collected in the Uses map.
Types map[ast.Expr]types.TypeAndValue
// Instances maps identifiers denoting generic types or functions to their
// type arguments and instantiated type.
//
// For example, Instances will map the identifier for 'T' in the type
// instantiation T[int, string] to the type arguments [int, string] and
// resulting instantiated *Named type. Given a generic function
// func F[A any](A), Instances will map the identifier for 'F' in the call
// expression F(int(1)) to the inferred type arguments [int], and resulting
// instantiated *Signature.
//
// Invariant: Instantiating Uses[id].Type() with Instances[id].TypeArgs
// results in an equivalent of Instances[id].Type.
Instances map[*ast.Ident]types.Instance
// Defs maps identifiers to the objects they define (including
// package names, dots "." of dot-imports, and blank "_" identifiers).
// For identifiers that do not denote objects (e.g., the package name
// in package clauses, or symbolic variables t in t := x.(type) of
// type switch headers), the corresponding objects are nil.
//
// For an embedded field, Defs returns the field *Var it defines.
//
// Invariant: Defs[id] == nil || Defs[id].Pos() == id.Pos()
Defs map[*ast.Ident]types.Object
// Uses maps identifiers to the objects they denote.
//
// For an embedded field, Uses returns the *TypeName it denotes.
//
// Invariant: Uses[id].Pos() != id.Pos()
Uses map[*ast.Ident]types.Object
// Implicits maps nodes to their implicitly declared objects, if any.
// The following node and object types may appear:
//
// node declared object
//
// *ast.ImportSpec *PkgName for imports without renames
// *ast.CaseClause type-specific *Var for each type switch case clause (incl. default)
// *ast.Field anonymous parameter *Var (incl. unnamed results)
//
Implicits map[ast.Node]types.Object
// Selections maps selector expressions (excluding qualified identifiers)
// to their corresponding selections.
Selections map[*ast.SelectorExpr]*types.Selection
// Scopes maps ast.Nodes to the scopes they define. Package scopes are not
// associated with a specific node but with all files belonging to a package.
// Thus, the package scope can be found in the type-checked Package object.
// Scopes nest, with the Universe scope being the outermost scope, enclosing
// the package scope, which contains (one or more) files scopes, which enclose
// function scopes which in turn enclose statement and function literal scopes.
// Note that even though package-level functions are declared in the package
// scope, the function scopes are embedded in the file scope of the file
// containing the function declaration.
//
// The following node types may appear in Scopes:
//
// *ast.File
// *ast.FuncType
// *ast.TypeSpec
// *ast.BlockStmt
// *ast.IfStmt
// *ast.SwitchStmt
// *ast.TypeSwitchStmt
// *ast.CaseClause
// *ast.CommClause
// *ast.ForStmt
// *ast.RangeStmt
//
Scopes map[ast.Node]*types.Scope
}
Info holds result type information for a type-checked package. Only the information for which a map is provided is collected. If the package has type errors, the collected information may be incomplete.
Source Files
Directories