NewContext creates a new Context.

Note: NewMethodSet is intended for external use only as it requires interfaces to be complete. It may be used internally if LookupFieldOrMethod comple

NewTypeParam returns a new TypeParam. Type parameters may be set on a Named or Signature type by calling SetTypeParams. Setting a type parameter on mo

Opaque type of n bytes.

Convenience functions.

SetUnderlying sets the underlying type and marks t as complete. t must not have type arguments.

(inherit methods from Int) add adds b to the set and returns true if the set changed.

addDeclDep adds the dependency edge (check.decl -> to) if check.decl exists

base strips away qualifiers and typedefs to get the underlying type

context must be a non-empty string unless we know that p.tok == _Lbrace.

call interprets a call to a function (function, builtin or closure) fn with arguments args, returning its result. callpos is the position of the calls

deref returns a pointer's element type; otherwise it returns typ. TODO(adonovan): Import from ssa?

emitCompare emits to f code compute the boolean result of comparison comparison 'x op y'.

emitNew emits to f a new (heap Alloc) instruction allocating an object of type typ. pos is the optional source location.

gofmt returns the gofmt-formatted string for an AST node.

gotAssign is like got(_Assign) but it also accepts ":=" (and reports an error) for better parser error recovery.

hasNil reports whether type t includes the nil value.

implements checks if V implements T and reports an error if it doesn't. The receiver may be nil if implements is called through an exported API call s

initialized lazily insert attempts to insert an object obj into objset s. If s already contains an alternative object alt with the same name, insert l

The isX predicates below report whether t is an X. If t is a type parameter the result is false; i.e., these predicates don't look inside a type param

isGeneric reports whether a type is a generic, uninstantiated type (generic signatures are not included). TODO(gri) should we include signatures or as

isNonTypeParamInterface reports whether t is an interface type but not a type parameter.

logStack prints the formatted "start" message to stderr and returns a closure that prints the corresponding "end" message. Call using 'defer logStack(

newDefined creates a new defined type named T with the given underlying type.

order reflects a package-level object's source order: if object a is before object b in the source, then a.order() < b.order(). order returns a value

pos returns the (line, col) source position of s.ch.

recordInstance records instantiation information into check.Info, if the Instances map is non-nil. The given expr must be an ident, selector, or index

sameId reports whether obj.Id() and Id(pkg, name) are the same.

set sets the type typ for the i'th type parameter; typ must not be nil and it must not have been set before.

setCall emits to fn code to evaluate all the parameters of a function call e, and populates *c with those values.

Implements printing of Go values in the style of built-in println.

If tpar is a type parameter in list, tparamIndex returns the type parameter index. Otherwise, the result is < 0. tpar must not be nil.

updateExprType updates the type of x to typ and invokes itself recursively for the operands of x, depending on expression kind. If typ is still an unt

Anonymous reports whether the variable is an embedded field. Same as Embedded; only present for backward-compatibility.

Crawl traverses a syntax in pre-order: It starts by calling f(root); root must not be nil. If f returns false (== "continue"), Crawl calls f recursive

Delete removes the entry with the given key, if any. It returns true if the entry was found.

Implements reports whether type V implements interface T. The behavior of Implements is undefined if V is an uninstantiated generic type.

ImportedPackage returns the importable Package whose PkgPath is path, or nil if no such Package has been created. A parameter to CreatePackage determ

Insert attempts to insert an object obj into scope s. If s already contains an alternative object alt with the same name, Insert leaves s unchanged an

Inspect traverses an AST in pre-order: It starts by calling f(node); node must not be nil. If f returns true, Inspect invokes f recursively for each o

IsEmpty reports whether type set s is the empty set.

IsMethodSet reports whether the interface t is fully described by its method set.

NewStruct returns a new struct with the given fields and corresponding field tags. If a field with index i has a tag, tags[i] must be that tag, but le

NewUnion returns a new Union type with the given terms. It is an error to create an empty union; they are syntactically not possible.

package-qualified name of the package member

Set sets the map entry for key to val, and returns the previous entry, if any.

package local object name

WriteSignature writes the representation of the signature sig to buf, without a leading "func" keyword. The Qualifier controls the printing of package

addLocal creates an anonymous local variable of type typ, adds it to function f and returns it. pos is the optional source location.

addNamedLocal creates a local variable, adds it to function f and returns it. Its name and type are taken from obj. Subsequent calls to f.lookup(obj

addParamObj adds a (non-escaping) parameter to f.Params for the specified Var. If spill is true, then the parameter is pre-spilled to the stack; the

The allX predicates below report whether t is an X. If t is a type parameter the result is true if isX is true for all specified types of the type par

arity checks that the lhs and rhs of a const or var decl have a matching number of names and initialization values. If inherited is set, the initializ

If dynamic is set, non-type parameter interfaces are always comparable. If reportf != nil, it may be used to report why T is not comparable.

Returns initially created packages, as a string.

cycleError reports a declaration cycle starting with the object in cycle that is "first" in the source.

definedType is like typ but also accepts a type name def. If def != nil, e is the type specification for the defined type def, declared in a type decl

entries returns a rangeable map of entries.

equals returns true iff x and y are equal according to Go's linguistic equivalence relation for type t. In a well-typed program, the dynamic types of

error reports the error msg at source position s.pos().