exclude reports an error if x.mode is in modeset and sets x.mode to invalid. The modeset may contain any of 1<<novalue, 1<<builtin, 1<<typexpr.

exprOrType typechecks expression or type e and initializes x with the expression value or type. If allowGeneric is set, the operand type may be an uni

funcString returns a string of the form name + signature for f. check may be nil.

gofmtLine returns the gofmt-formatted string for an AST node, ensuring that it is on a single line.

---------------------------------------------------------------------------- Implementation hasTerms reports whether the type set has specific type te

implicitTypeAndValue returns the implicit type of x when used in a context where the target type is expected. If no such implicit conversion is possib

Returns initially imported packages, as a string.

includes reports whether t ∈ x.

index checks an index expression for validity. If max >= 0, it is the upper bound for index. If the result typ is != Typ[Invalid], index is valid and

instanceHash returns a string representation of typ instantiated with targs. The hash should be a perfect hash, though out of caution the type checker

Expr for integer n.

intersect returns the intersection x ∩ y.

isStructUnionClass reports whether the type described by the Go syntax x is a struct, union, or class with a tag.

---------------------------------------------------------------------------- Declarations list parses a possibly empty, sep-separated list of elements

---------------------------------------------------------------------------- Implementation

check may be nil

newNamed is like NewNamed but with a *Checker receiver and additional orig argument.

newTypeList returns a new TypeList with the types in list.

representableConst reports whether x can be represented as value of the given basic type and for the configuration provided (only needed for int/uint

setLit sets the scanner state for a recognized _Literal token.

singleValue reports an error if x describes a tuple and sets x.mode to invalid.

types returns the list of inferred types (via unification) for the type parameters described by d, and an index. If all types were inferred, the retur

typesSummary returns a string of the form "(t1, t2, ...)" where the ti's are user-friendly string representations for the given types. If variadic is

If typ is a type parameter, underIs returns the result of typ.underIs(f). Otherwise, underIs returns the result of f(under(typ)).

update de-duplicates n against previously seen types with the hash h. If an identical type is found with the type hash h, the previously seen type is

like T0 with different method names

validCycle reports whether the cycle starting with obj is valid and reports an error if it is not.

write is a thin wrapper around p.output.Write that takes care of accounting and error handling.

Addressable reports whether the corresponding expression is addressable (https://golang.org/ref/spec#Address_operators).

AssignableTo reports whether a value of type V is assignable to a variable of type T. The behavior of AssignableTo is undefined if V or T is an unins

DefPredeclaredTestFuncs defines the assert and trace built-ins. These built-ins are intended for debugging and testing of this package only.

Empty reports whether t is the empty interface.

object type

Id returns name if it is exported, otherwise it returns the name qualified with the package path.

IdenticalIgnoreTags reports whether x and y are identical types if tags are ignored. Receivers of Signature types are ignored.

Imported returns the package that was imported. It is distinct from Pkg(), which is the package containing the import statement.

Innermost returns the innermost (child) scope containing pos. If pos is not within any scope, the result is nil. The result is also nil for the Univer

IsType reports whether the corresponding expression specifies a type.

IsValue reports whether the corresponding expression is a value. Builtins are not considered values. Constant values have a non- nil Value.

Len returns the number of methods in s.

LookupMethod returns the implementation of the method of type T identified by (pkg, name). It returns nil if the method exists but is abstract, and p

MakeHasher returns a new Hasher instance.

MethodValue returns the Function implementing method sel, building wrapper methods on demand. It returns nil if sel denotes an abstract (interface) m

Name returns the package name.

package to which this object belongs; nil for labels and objects in the Universe scope

NewConst returns a new constant with value val. The remaining arguments set the attributes found with all Objects.

NewProgram returns a new SSA Program. mode controls diagnostics and checking during SSA construction.

Next returns the next key and value pair, and a boolean indicating whether they are valid or whether we have reached the end.

like String, but relative refs are unqualified

ObjectOf returns the object denoted by the specified id, or nil if not found. If id is an embedded struct field, ObjectOf returns the field (*Var) it

Packages creates an SSA program for a set of packages. The packages must have been loaded from source syntax using the golang.org/x/tools/go/packages

RecvTypeParams returns the receiver type parameters of signature s, or nil.

Reduce reduces a []T1 to a single value using a reduction function.

Reverse is a generic function that takes a []T argument and reverses that slice in place.

Split splits s into a list of fields, allowing single or double quotes around elements. There is no unescaping or other processing within quoted field

String returns a string representation of the map's entries. Values are printed using fmt.Sprintf("%v", v). Order is unspecified.

String is for testing.

Take returns the current Pragma to apply to the next package, import, const, func, type, or var declaration.

addEdge adds a control-flow graph edge from from to to.

addFiles adds and type-checks the specified files to info, loading their dependencies if needed. The order of files determines the package initializa

Returns all loaded packages.

arrayPtrDeref returns A if typ is of the form *A and A is an array; otherwise it returns typ.

"[" has already been consumed, and pos is its position, and open is its tape index. If len != nil it is the already consumed array length.