Params returns the parameters of signature s, or nil.

assignment reports whether x can be assigned to a variable of type T, if necessary by attempting to convert untyped values to the appropriate type. co

Bytes returns a new byte slice containing the original data with the queued edits applied.

deref returns a pointer's element type; otherwise it returns typ.

NewPackage returns a new Package for the given package path and name. The package is not complete and contains no explicit imports.

makeSig makes a signature for the given argument and result types. Default types are used for untyped arguments, and res may be nil.

---------------------------------------------------------------------------- Common productions

next advances the scanner by reading the next token. If a read, source encoding, or lexical error occurs, next calls the installed error handler with

position of object identifier in declaration

allowVersion reports whether the given package is allowed to use version major.minor.

emitExtract emits to f an instruction to extract the index'th component of tuple. It returns the extracted value.

Call a function for each entry in an ast.FieldList, passing the index into the list, the name if any, and the type.

Given a reflect.Value, returns the underlying interpreter value.

Import is a convenience function that adds path to ImportPkgs, the set of initial packages that will be imported from source.

Results returns the results of signature s, or nil.

If t is not a type parameter, coreType returns the underlying type. If t is a type parameter, coreType returns the single underlying type of all types

emitLoad emits to f an instruction to load the address addr into a new temporary, and returns the value so defined.

errorf reports an error at the most recently read character position.

use type-checks each argument. Useful to make sure expressions are evaluated (and variables are "used") in the presence of other errors. The arguments

varType type-checks the type expression e and returns its type, or Typ[Invalid]. The type must not be an (uninstantiated) generic type and it must not

Build calls Package.Build for each package in prog. Building occurs in parallel unless the BuildSerially mode flag was set. Build is intended for who

NewSlice returns a new slice type for the given element type.

NodeString is a convenience function that prints n in ShortForm and returns the printed string.

ParseFile behaves like Parse but it reads the source from the named file.

Uint64 returns the numeric value of this constant truncated to fit an unsigned 64-bit integer.

---------------------------------------------------------------------------- Expressions

maketl makes a term list from a string of the term list.

Hash computes a hash value for the given type t such that Identical(t, t') => Hash(t) == Hash(t').

reports whether the name starts with a capital letter

NewSSAConst returns a new constant of the specified value and type. val must be valid according to the specification of Const.Value.

ObjectString returns the string form of obj. The Qualifier controls the printing of package-level objects, and may be nil.

Parse parses a single Go source file from src and returns the corresponding syntax tree. If there are errors, Parse will return the first error found,

expr lowers a single-result expression e to SSA form, emitting code to fn and returning the Value defined by the expression.

subst returns the type typ with its type parameters tpars replaced by the corresponding type arguments targs, recursively. subst doesn't modify the in

Key returns the key type of map m.

ReadAny reads and returns the next value from the buffer. If no value is available, it panics.

StartPos returns the start position of n.

WriteAny appends x to the buffer, growing the buffer as needed.

error reports an error at the given position.

Deprecated: Use init instead.

TODO(gri) TypeSet.is and TypeSet.underIs should probably also go into termlist.go is calls f with the specific type terms of s and reports whether all

newMethod creates a new method of the specified name, package and receiver type.

typeOrNil is like type_ but it returns nil if there was no type instead of reporting an error. Type = TypeName | TypeLit | "(" Type ")" . TypeNam

zero returns a new "zero" value of the specified type.

NewInterfaceType returns a new interface for the given methods and embedded types. NewInterfaceType takes ownership of the provided methods and may mo

NewTerm returns a new union term.

This file defines utilities for working with source positions or source-level named entities ("objects"). TODO(adonovan): test that {Value,Instruction

TypeOf returns the type of expression e, or nil if not found. Precondition: the Types, Uses and Defs maps are populated.

WriteTo writes a string representation of the scope to w, with the scope elements sorted by name. The level of indentation is controlled by n >= 0, wi

If debug is set, describef sets a printf-formatted description for action a. Otherwise, it is a no-op.

later pushes f on to the stack of actions that will be processed later; either at the end of the current statement, or in case of a local constant or

address of the location

Default returns the default "typed" type for an "untyped" type; it returns the incoming type for all other types. The default type for untyped nil is

Internal use of LookupFieldOrMethod: If the obj result is a method associated with a concrete (non-interface) type, the method's signature may not be

NewFileBase returns a new PosBase for the given filename. A file PosBase's position is relative to itself, with the position being filename:1:1.

NewFunc returns a new function with the given signature, representing the function's type.

NewSignatureType creates a new function type for the given receiver, receiver type parameters, type parameters, parameters, and results. If variadic i

Referrers returns the list of instructions that have this value as one of their operands; it may contain duplicates if an instruction has a repeated o

asInt converts x, which must be an integer, to an int suitable for use as a slice or array index or operand to make().

convertUntyped attempts to set the type of an untyped value to the target type.