Global

class method AssertableTo(V: Memory<Interface>; T: Type): bool

static bool AssertableTo(Memory<Interface> V, Type T)

static func AssertableTo(_ V: Memory<Interface>, _ T: Type) -> bool

func AssertableTo(V Memory<Interface>, T Type) bool

Shared Function AssertableTo(V As Memory<Interface>, T As Type) As bool

class method AssignableTo(V: Type; T: Type): bool

static bool AssignableTo(Type V, Type T)

static func AssignableTo(_ V: Type, _ T: Type) -> bool

func AssignableTo(V Type, T Type) bool

Shared Function AssignableTo(V As Type, T As Type) As bool

const Bool: BasicKind = 1

const BasicKind Bool = 1

static let Bool: BasicKind = 1

const Bool BasicKind = 1

Const Bool As BasicKind = 1

const Byte: BasicKind = 8

const BasicKind Byte = 8

static let Byte: BasicKind = 8

const Byte BasicKind = 8

Const Byte As BasicKind = 8

class method CheckExpr(fset: Memory<FileSet>; pkg: Memory<Package>; pos: Pos; expr: Expr; info: Memory<Info>): error

static error CheckExpr(Memory<FileSet> fset, Memory<Package> pkg, Pos pos, Expr expr, Memory<Info> info)

static func CheckExpr(_ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ pos: Pos, _ expr: Expr, _ info: Memory<Info>) -> error

func CheckExpr(fset Memory<FileSet>, pkg Memory<Package>, pos Pos, expr Expr, info Memory<Info>) error

Shared Function CheckExpr(fset As Memory<FileSet>, pkg As Memory<Package>, pos As Pos, expr As Expr, info As Memory<Info>) As error

class method Comparable(T: Type): bool

static bool Comparable(Type T)

static func Comparable(_ T: Type) -> bool

func Comparable(T Type) bool

Shared Function Comparable(T As Type) As bool

const Complex128: BasicKind = 16

const BasicKind Complex128 = 16

static let Complex128: BasicKind = 16

const Complex128 BasicKind = 16

Const Complex128 As BasicKind = 16

const Complex64: BasicKind = 15

const BasicKind Complex64 = 15

static let Complex64: BasicKind = 15

const Complex64 BasicKind = 15

Const Complex64 As BasicKind = 15

class method ConvertibleTo(V: Type; T: Type): bool

static bool ConvertibleTo(Type V, Type T)

static func ConvertibleTo(_ V: Type, _ T: Type) -> bool

func ConvertibleTo(V Type, T Type) bool

Shared Function ConvertibleTo(V As Type, T As Type) As bool

class method Default(typ: Type): Type

static Type Default(Type typ)

static func Default(_ typ: Type) -> Type

func Default(typ Type) Type

Shared Function Default(typ As Type) As Type

class method DefPredeclaredTestFuncs

static void DefPredeclaredTestFuncs()

static func DefPredeclaredTestFuncs()

// .NET, .NET Standard 2.0
func DefPredeclaredTestFuncs() 
// Island
func DefPredeclaredTestFuncs() void

Shared Sub DefPredeclaredTestFuncs()

class method Eval(fset: Memory<FileSet>; pkg: Memory<Package>; pos: Pos; expr: string): tuple of (_: TypeAndValue, err: error)

static (TypeAndValue _, error err) Eval(Memory<FileSet> fset, Memory<Package> pkg, Pos pos, string expr)

static func Eval(_ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ pos: Pos, _ expr: string) -> tuple of (TypeAndValue, error)

func Eval(fset Memory<FileSet>, pkg Memory<Package>, pos Pos, expr string) tuple of (|name=_| TypeAndValue, |name=err| error)

Shared Function Eval(fset As Memory<FileSet>, pkg As Memory<Package>, pos As Pos, expr As string) As Tuple (Of TypeAndValue, error)

class method ExprString(x: Expr): string

static string ExprString(Expr x)

static func ExprString(_ x: Expr) -> string

func ExprString(x Expr) string

Shared Function ExprString(x As Expr) As string

const FieldVal: SelectionKind = 0

const SelectionKind FieldVal = 0

static let FieldVal: SelectionKind = 0

const FieldVal SelectionKind = 0

Const FieldVal As SelectionKind = 0

const Float32: BasicKind = 13

const BasicKind Float32 = 13

static let Float32: BasicKind = 13

const Float32 BasicKind = 13

Const Float32 As BasicKind = 13

const Float64: BasicKind = 14

const BasicKind Float64 = 14

static let Float64: BasicKind = 14

const Float64 BasicKind = 14

Const Float64 As BasicKind = 14

class method Id(pkg: Memory<Package>; name: string): string

static string Id(Memory<Package> pkg, string name)

static func Id(_ pkg: Memory<Package>, _ name: string) -> string

func Id(pkg Memory<Package>, name string) string

Shared Function Id(pkg As Memory<Package>, name As string) As string

class method Identical(x: Type; y: Type): bool

static bool Identical(Type x, Type y)

static func Identical(_ x: Type, _ y: Type) -> bool

func Identical(x Type, y Type) bool

Shared Function Identical(x As Type, y As Type) As bool

class method IdenticalIgnoreTags(x: Type; y: Type): bool

static bool IdenticalIgnoreTags(Type x, Type y)

static func IdenticalIgnoreTags(_ x: Type, _ y: Type) -> bool

func IdenticalIgnoreTags(x Type, y Type) bool

Shared Function IdenticalIgnoreTags(x As Type, y As Type) As bool

class method Implements(V: Type; T: Memory<Interface>): bool

static bool Implements(Type V, Memory<Interface> T)

static func Implements(_ V: Type, _ T: Memory<Interface>) -> bool

func Implements(V Type, T Memory<Interface>) bool

Shared Function Implements(V As Type, T As Memory<Interface>) As bool

const Int: BasicKind = 2

const BasicKind Int = 2

static let Int: BasicKind = 2

const Int BasicKind = 2

Const Int As BasicKind = 2

const Int16: BasicKind = 4

const BasicKind Int16 = 4

static let Int16: BasicKind = 4

const Int16 BasicKind = 4

Const Int16 As BasicKind = 4

const Int32: BasicKind = 5

const BasicKind Int32 = 5

static let Int32: BasicKind = 5

const Int32 BasicKind = 5

Const Int32 As BasicKind = 5

const Int64: BasicKind = 6

const BasicKind Int64 = 6

static let Int64: BasicKind = 6

const Int64 BasicKind = 6

Const Int64 As BasicKind = 6

const Int8: BasicKind = 3

const BasicKind Int8 = 3

static let Int8: BasicKind = 3

const Int8 BasicKind = 3

Const Int8 As BasicKind = 3

const Invalid: BasicKind = 0

const BasicKind Invalid = 0

static let Invalid: BasicKind = 0

const Invalid BasicKind = 0

Const Invalid As BasicKind = 0

const IsBoolean: BasicInfo = 1

const BasicInfo IsBoolean = 1

static let IsBoolean: BasicInfo = 1

const IsBoolean BasicInfo = 1

Const IsBoolean As BasicInfo = 1

const IsComplex: BasicInfo = 16

const BasicInfo IsComplex = 16

static let IsComplex: BasicInfo = 16

const IsComplex BasicInfo = 16

Const IsComplex As BasicInfo = 16

const IsConstType: BasicInfo = 59

const BasicInfo IsConstType = 59

static let IsConstType: BasicInfo = 59

const IsConstType BasicInfo = 59

Const IsConstType As BasicInfo = 59

const IsFloat: BasicInfo = 8

const BasicInfo IsFloat = 8

static let IsFloat: BasicInfo = 8

const IsFloat BasicInfo = 8

Const IsFloat As BasicInfo = 8

const IsInteger: BasicInfo = 2

const BasicInfo IsInteger = 2

static let IsInteger: BasicInfo = 2

const IsInteger BasicInfo = 2

Const IsInteger As BasicInfo = 2

class method IsInterface(typ: Type): bool

static bool IsInterface(Type typ)

static func IsInterface(_ typ: Type) -> bool

func IsInterface(typ Type) bool

Shared Function IsInterface(typ As Type) As bool

const IsNumeric: BasicInfo = 26

const BasicInfo IsNumeric = 26

static let IsNumeric: BasicInfo = 26

const IsNumeric BasicInfo = 26

Const IsNumeric As BasicInfo = 26

const IsOrdered: BasicInfo = 42

const BasicInfo IsOrdered = 42

static let IsOrdered: BasicInfo = 42

const IsOrdered BasicInfo = 42

Const IsOrdered As BasicInfo = 42

const IsString: BasicInfo = 32

const BasicInfo IsString = 32

static let IsString: BasicInfo = 32

const IsString BasicInfo = 32

Const IsString As BasicInfo = 32

const IsUnsigned: BasicInfo = 4

const BasicInfo IsUnsigned = 4

static let IsUnsigned: BasicInfo = 4

const IsUnsigned BasicInfo = 4

Const IsUnsigned As BasicInfo = 4

const IsUntyped: BasicInfo = 64

const BasicInfo IsUntyped = 64

static let IsUntyped: BasicInfo = 64

const IsUntyped BasicInfo = 64

Const IsUntyped As BasicInfo = 64

class method LookupFieldOrMethod(T: Type; addressable: bool; pkg: Memory<Package>; name: string): tuple of (obj: Object, index: Slice<Int64>, indirect: Boolean)

static (Object obj, Slice<Int64>index, Boolean indirect) LookupFieldOrMethod(Type T, bool addressable, Memory<Package> pkg, string name)

static func LookupFieldOrMethod(_ T: Type, _ addressable: bool, _ pkg: Memory<Package>, _ name: string) -> tuple of (Object, Slice<Int64>, Boolean)

func LookupFieldOrMethod(T Type, addressable bool, pkg Memory<Package>, name string) tuple of (|name=obj| Object, |name=index| Slice<Int64>, |name=indirect| Boolean)

Shared Function LookupFieldOrMethod(T As Type, addressable As bool, pkg As Memory<Package>, name As string) As Tuple (Of Object, Slice<Int64>, Boolean)

const MethodExpr: SelectionKind = 2

const SelectionKind MethodExpr = 2

static let MethodExpr: SelectionKind = 2

const MethodExpr SelectionKind = 2

Const MethodExpr As SelectionKind = 2

const MethodVal: SelectionKind = 1

const SelectionKind MethodVal = 1

static let MethodVal: SelectionKind = 1

const MethodVal SelectionKind = 1

Const MethodVal As SelectionKind = 1

class method MissingMethod(V: Type; T: Memory<Interface>; static: bool): tuple of (method: Memory<Func>, wrongType: Boolean)

static (Memory<Func>method, Boolean wrongType) MissingMethod(Type V, Memory<Interface> T, bool static)

static func MissingMethod(_ V: Type, _ T: Memory<Interface>, _ static: bool) -> tuple of (Memory<Func>, Boolean)

func MissingMethod(V Type, T Memory<Interface>, static bool) tuple of (|name=method| Memory<Func>, |name=wrongType| Boolean)

Shared Function MissingMethod(V As Type, T As Memory<Interface>, static As bool) As Tuple (Of Memory<Func>, Boolean)

class method NewArray(elem: Type; len: int64): Memory<Array>

static Memory<Array> NewArray(Type elem, int64 len)

static func NewArray(_ elem: Type, _ len: int64) -> Memory<Array>

func NewArray(elem Type, len int64) Memory<Array>

Shared Function NewArray(elem As Type, len As int64) As Memory<Array>

class method NewChan(dir: ChanDir; elem: Type): Memory<Chan>

static Memory<Chan> NewChan(ChanDir dir, Type elem)

static func NewChan(_ dir: ChanDir, _ elem: Type) -> Memory<Chan>

func NewChan(dir ChanDir, elem Type) Memory<Chan>

Shared Function NewChan(dir As ChanDir, elem As Type) As Memory<Chan>

class method NewChecker(conf: Memory<Config>; fset: Memory<FileSet>; pkg: Memory<Package>; info: Memory<Info>): Memory<Checker>

static Memory<Checker> NewChecker(Memory<Config> conf, Memory<FileSet> fset, Memory<Package> pkg, Memory<Info> info)

static func NewChecker(_ conf: Memory<Config>, _ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ info: Memory<Info>) -> Memory<Checker>

func NewChecker(conf Memory<Config>, fset Memory<FileSet>, pkg Memory<Package>, info Memory<Info>) Memory<Checker>

Shared Function NewChecker(conf As Memory<Config>, fset As Memory<FileSet>, pkg As Memory<Package>, info As Memory<Info>) As Memory<Checker>

class method NewConst(pos: Pos; pkg: Memory<Package>; name: string; typ: Type; val: Value): Memory<Const>

static Memory<Const> NewConst(Pos pos, Memory<Package> pkg, string name, Type typ, Value val)

static func NewConst(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type, _ val: Value) -> Memory<Const>

func NewConst(pos Pos, pkg Memory<Package>, name string, typ Type, val Value) Memory<Const>

Shared Function NewConst(pos As Pos, pkg As Memory<Package>, name As string, typ As Type, val As Value) As Memory<Const>

class method NewField(pos: Pos; pkg: Memory<Package>; name: string; typ: Type; embedded: bool): Memory<Var>

static Memory<Var> NewField(Pos pos, Memory<Package> pkg, string name, Type typ, bool embedded)

static func NewField(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type, _ embedded: bool) -> Memory<Var>

func NewField(pos Pos, pkg Memory<Package>, name string, typ Type, embedded bool) Memory<Var>

Shared Function NewField(pos As Pos, pkg As Memory<Package>, name As string, typ As Type, embedded As bool) As Memory<Var>

class method NewFunc(pos: Pos; pkg: Memory<Package>; name: string; sig: Memory<Signature>): Memory<Func>

static Memory<Func> NewFunc(Pos pos, Memory<Package> pkg, string name, Memory<Signature> sig)

static func NewFunc(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ sig: Memory<Signature>) -> Memory<Func>

func NewFunc(pos Pos, pkg Memory<Package>, name string, sig Memory<Signature>) Memory<Func>

Shared Function NewFunc(pos As Pos, pkg As Memory<Package>, name As string, sig As Memory<Signature>) As Memory<Func>

class method NewInterface(methods: Slice<Memory<Func>>; embeddeds: Slice<Memory<Named>>): Memory<Interface>

static Memory<Interface> NewInterface(Slice<Memory<Func>> methods, Slice<Memory<Named>> embeddeds)

static func NewInterface(_ methods: Slice<Memory<Func>>, _ embeddeds: Slice<Memory<Named>>) -> Memory<Interface>

func NewInterface(methods Slice<Memory<Func>>, embeddeds Slice<Memory<Named>>) Memory<Interface>

Shared Function NewInterface(methods As Slice<Memory<Func>>, embeddeds As Slice<Memory<Named>>) As Memory<Interface>

class method NewInterfaceType(methods: Slice<Memory<Func>>; embeddeds: Slice<Type>): Memory<Interface>

static Memory<Interface> NewInterfaceType(Slice<Memory<Func>> methods, Slice<Type> embeddeds)

static func NewInterfaceType(_ methods: Slice<Memory<Func>>, _ embeddeds: Slice<Type>) -> Memory<Interface>

func NewInterfaceType(methods Slice<Memory<Func>>, embeddeds Slice<Type>) Memory<Interface>

Shared Function NewInterfaceType(methods As Slice<Memory<Func>>, embeddeds As Slice<Type>) As Memory<Interface>

class method NewLabel(pos: Pos; pkg: Memory<Package>; name: string): Memory<Label>

static Memory<Label> NewLabel(Pos pos, Memory<Package> pkg, string name)

static func NewLabel(_ pos: Pos, _ pkg: Memory<Package>, _ name: string) -> Memory<Label>

func NewLabel(pos Pos, pkg Memory<Package>, name string) Memory<Label>

Shared Function NewLabel(pos As Pos, pkg As Memory<Package>, name As string) As Memory<Label>

class method NewMap(key: Type; elem: Type): Memory<Map>

static Memory<Map> NewMap(Type key, Type elem)

static func NewMap(_ key: Type, _ elem: Type) -> Memory<Map>

func NewMap(key Type, elem Type) Memory<Map>

Shared Function NewMap(key As Type, elem As Type) As Memory<Map>

class method NewMethodSet(T: Type): Memory<MethodSet>

static Memory<MethodSet> NewMethodSet(Type T)

static func NewMethodSet(_ T: Type) -> Memory<MethodSet>

func NewMethodSet(T Type) Memory<MethodSet>

Shared Function NewMethodSet(T As Type) As Memory<MethodSet>

class method NewNamed(obj: Memory<TypeName>; underlying: Type; methods: Slice<Memory<Func>>): Memory<Named>

static Memory<Named> NewNamed(Memory<TypeName> obj, Type underlying, Slice<Memory<Func>> methods)

static func NewNamed(_ obj: Memory<TypeName>, _ underlying: Type, _ methods: Slice<Memory<Func>>) -> Memory<Named>

func NewNamed(obj Memory<TypeName>, underlying Type, methods Slice<Memory<Func>>) Memory<Named>

Shared Function NewNamed(obj As Memory<TypeName>, underlying As Type, methods As Slice<Memory<Func>>) As Memory<Named>

class method NewPackage(path: string; name: string): Memory<Package>

static Memory<Package> NewPackage(string path, string name)

static func NewPackage(_ path: string, _ name: string) -> Memory<Package>

func NewPackage(path string, name string) Memory<Package>

Shared Function NewPackage(path As string, name As string) As Memory<Package>

class method NewParam(pos: Pos; pkg: Memory<Package>; name: string; typ: Type): Memory<Var>

static Memory<Var> NewParam(Pos pos, Memory<Package> pkg, string name, Type typ)

static func NewParam(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type) -> Memory<Var>

func NewParam(pos Pos, pkg Memory<Package>, name string, typ Type) Memory<Var>

Shared Function NewParam(pos As Pos, pkg As Memory<Package>, name As string, typ As Type) As Memory<Var>

class method NewPkgName(pos: Pos; pkg: Memory<Package>; name: string; imported: Memory<Package>): Memory<PkgName>

static Memory<PkgName> NewPkgName(Pos pos, Memory<Package> pkg, string name, Memory<Package> imported)

static func NewPkgName(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ imported: Memory<Package>) -> Memory<PkgName>

func NewPkgName(pos Pos, pkg Memory<Package>, name string, imported Memory<Package>) Memory<PkgName>

Shared Function NewPkgName(pos As Pos, pkg As Memory<Package>, name As string, imported As Memory<Package>) As Memory<PkgName>

class method NewPointer(elem: Type): Memory<Pointer>

static Memory<Pointer> NewPointer(Type elem)

static func NewPointer(_ elem: Type) -> Memory<Pointer>

func NewPointer(elem Type) Memory<Pointer>

Shared Function NewPointer(elem As Type) As Memory<Pointer>

class method NewScope(parent: Memory<Scope>; pos: Pos; end: Pos; comment: string): Memory<Scope>

static Memory<Scope> NewScope(Memory<Scope> parent, Pos pos, Pos end, string comment)

static func NewScope(_ parent: Memory<Scope>, _ pos: Pos, _ end: Pos, _ comment: string) -> Memory<Scope>

func NewScope(parent Memory<Scope>, pos Pos, end Pos, comment string) Memory<Scope>

Shared Function NewScope(parent As Memory<Scope>, pos As Pos, end As Pos, comment As string) As Memory<Scope>

class method NewSignature(recv: Memory<Var>; params: Memory<Tuple>; results: Memory<Tuple>; variadic: bool): Memory<Signature>

static Memory<Signature> NewSignature(Memory<Var> recv, Memory<Tuple> params, Memory<Tuple> results, bool variadic)

static func NewSignature(_ recv: Memory<Var>, _ params: Memory<Tuple>, _ results: Memory<Tuple>, _ variadic: bool) -> Memory<Signature>

func NewSignature(recv Memory<Var>, params Memory<Tuple>, results Memory<Tuple>, variadic bool) Memory<Signature>

Shared Function NewSignature(recv As Memory<Var>, params As Memory<Tuple>, results As Memory<Tuple>, variadic As bool) As Memory<Signature>

class method NewSlice(elem: Type): Memory<Slice>

static Memory<Slice> NewSlice(Type elem)

static func NewSlice(_ elem: Type) -> Memory<Slice>

func NewSlice(elem Type) Memory<Slice>

Shared Function NewSlice(elem As Type) As Memory<Slice>

class method NewStruct(fields: Slice<Memory<Var>>; tags: Slice<string>): Memory<Struct>

static Memory<Struct> NewStruct(Slice<Memory<Var>> fields, Slice<string> tags)

static func NewStruct(_ fields: Slice<Memory<Var>>, _ tags: Slice<string>) -> Memory<Struct>

func NewStruct(fields Slice<Memory<Var>>, tags Slice<string>) Memory<Struct>

Shared Function NewStruct(fields As Slice<Memory<Var>>, tags As Slice<string>) As Memory<Struct>

class method NewTuple(params x: array of Memory<Var>): Memory<Tuple>

static Memory<Tuple> NewTuple(params Memory<Var>[] x)

static func NewTuple(_ x: Memory<Var>...) -> Memory<Tuple>

func NewTuple(x []Memory<Var>) Memory<Tuple>

Shared Function NewTuple(ParamArray x As Memory<Var>()) As Memory<Tuple>

class method NewTypeName(pos: Pos; pkg: Memory<Package>; name: string; typ: Type): Memory<TypeName>

static Memory<TypeName> NewTypeName(Pos pos, Memory<Package> pkg, string name, Type typ)

static func NewTypeName(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type) -> Memory<TypeName>

func NewTypeName(pos Pos, pkg Memory<Package>, name string, typ Type) Memory<TypeName>

Shared Function NewTypeName(pos As Pos, pkg As Memory<Package>, name As string, typ As Type) As Memory<TypeName>

class method NewVar(pos: Pos; pkg: Memory<Package>; name: string; typ: Type): Memory<Var>

static Memory<Var> NewVar(Pos pos, Memory<Package> pkg, string name, Type typ)

static func NewVar(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type) -> Memory<Var>

func NewVar(pos Pos, pkg Memory<Package>, name string, typ Type) Memory<Var>

Shared Function NewVar(pos As Pos, pkg As Memory<Package>, name As string, typ As Type) As Memory<Var>

class method ObjectString(obj: Object; qf: Qualifier): string

static string ObjectString(Object obj, Qualifier qf)

static func ObjectString(_ obj: Object, _ qf: Qualifier) -> string

func ObjectString(obj Object, qf Qualifier) string

Shared Function ObjectString(obj As Object, qf As Qualifier) As string

const RecvOnly: ChanDir = 2

const ChanDir RecvOnly = 2

static let RecvOnly: ChanDir = 2

const RecvOnly ChanDir = 2

Const RecvOnly As ChanDir = 2

class method RelativeTo(pkg: Memory<Package>): Qualifier

static Qualifier RelativeTo(Memory<Package> pkg)

static func RelativeTo(_ pkg: Memory<Package>) -> Qualifier

func RelativeTo(pkg Memory<Package>) Qualifier

Shared Function RelativeTo(pkg As Memory<Package>) As Qualifier

const Rune: BasicKind = 5

const BasicKind Rune = 5

static let Rune: BasicKind = 5

const Rune BasicKind = 5

Const Rune As BasicKind = 5

class method SelectionString(s: Memory<Selection>; qf: Qualifier): string

static string SelectionString(Memory<Selection> s, Qualifier qf)

static func SelectionString(_ s: Memory<Selection>, _ qf: Qualifier) -> string

func SelectionString(s Memory<Selection>, qf Qualifier) string

Shared Function SelectionString(s As Memory<Selection>, qf As Qualifier) As string

const SendOnly: ChanDir = 1

const ChanDir SendOnly = 1

static let SendOnly: ChanDir = 1

const SendOnly ChanDir = 1

Const SendOnly As ChanDir = 1

const SendRecv: ChanDir = 0

const ChanDir SendRecv = 0

static let SendRecv: ChanDir = 0

const SendRecv ChanDir = 0

Const SendRecv As ChanDir = 0

class method SizesFor(compiler: string; arch: string): Sizes

static Sizes SizesFor(string compiler, string arch)

static func SizesFor(_ compiler: string, _ arch: string) -> Sizes

func SizesFor(compiler string, arch string) Sizes

Shared Function SizesFor(compiler As string, arch As string) As Sizes

const String: BasicKind = 17

const BasicKind String = 17

static let String: BasicKind = 17

const String BasicKind = 17

Const String As BasicKind = 17

class var Typ: Slice<Memory<Basic>>;

static Slice<Memory<Basic>> Typ

static var Typ: Slice<Memory<Basic>>

Typ Slice<Memory<Basic>>

Shared FIELD Typ() As Slice<Memory<Basic>>

class method TypeString(typ: Type; qf: Qualifier): string

static string TypeString(Type typ, Qualifier qf)

static func TypeString(_ typ: Type, _ qf: Qualifier) -> string

func TypeString(typ Type, qf Qualifier) string

Shared Function TypeString(typ As Type, qf As Qualifier) As string

const Uint: BasicKind = 7

const BasicKind Uint = 7

static let Uint: BasicKind = 7

const Uint BasicKind = 7

Const Uint As BasicKind = 7

const Uint16: BasicKind = 9

const BasicKind Uint16 = 9

static let Uint16: BasicKind = 9

const Uint16 BasicKind = 9

Const Uint16 As BasicKind = 9

const Uint32: BasicKind = 10

const BasicKind Uint32 = 10

static let Uint32: BasicKind = 10

const Uint32 BasicKind = 10

Const Uint32 As BasicKind = 10

const Uint64: BasicKind = 11

const BasicKind Uint64 = 11

static let Uint64: BasicKind = 11

const Uint64 BasicKind = 11

Const Uint64 As BasicKind = 11

const Uint8: BasicKind = 8

const BasicKind Uint8 = 8

static let Uint8: BasicKind = 8

const Uint8 BasicKind = 8

Const Uint8 As BasicKind = 8

const Uintptr: BasicKind = 12

const BasicKind Uintptr = 12

static let Uintptr: BasicKind = 12

const Uintptr BasicKind = 12

Const Uintptr As BasicKind = 12

class var Universe: Memory<Scope>;

static Memory<Scope> Universe

static var Universe: Memory<Scope>

Universe Memory<Scope>

Shared FIELD Universe() As Memory<Scope>

class var Unsafe: Memory<Package>;

static Memory<Package> Unsafe

static var Unsafe: Memory<Package>

Unsafe Memory<Package>

Shared FIELD Unsafe() As Memory<Package>

const UnsafePointer: BasicKind = 18

const BasicKind UnsafePointer = 18

static let UnsafePointer: BasicKind = 18

const UnsafePointer BasicKind = 18

Const UnsafePointer As BasicKind = 18

const UntypedBool: BasicKind = 19

const BasicKind UntypedBool = 19

static let UntypedBool: BasicKind = 19

const UntypedBool BasicKind = 19

Const UntypedBool As BasicKind = 19

const UntypedComplex: BasicKind = 23

const BasicKind UntypedComplex = 23

static let UntypedComplex: BasicKind = 23

const UntypedComplex BasicKind = 23

Const UntypedComplex As BasicKind = 23

const UntypedFloat: BasicKind = 22

const BasicKind UntypedFloat = 22

static let UntypedFloat: BasicKind = 22

const UntypedFloat BasicKind = 22

Const UntypedFloat As BasicKind = 22

const UntypedInt: BasicKind = 20

const BasicKind UntypedInt = 20

static let UntypedInt: BasicKind = 20

const UntypedInt BasicKind = 20

Const UntypedInt As BasicKind = 20

const UntypedNil: BasicKind = 25

const BasicKind UntypedNil = 25

static let UntypedNil: BasicKind = 25

const UntypedNil BasicKind = 25

Const UntypedNil As BasicKind = 25

const UntypedRune: BasicKind = 21

const BasicKind UntypedRune = 21

static let UntypedRune: BasicKind = 21

const UntypedRune BasicKind = 21

Const UntypedRune As BasicKind = 21

const UntypedString: BasicKind = 24

const BasicKind UntypedString = 24

static let UntypedString: BasicKind = 24

const UntypedString BasicKind = 24

Const UntypedString As BasicKind = 24

class method WriteExpr(buf: Memory<Buffer>; x: Expr)

static void WriteExpr(Memory<Buffer> buf, Expr x)

static func WriteExpr(_ buf: Memory<Buffer>, _ x: Expr)

// .NET, .NET Standard 2.0
func WriteExpr(buf Memory<Buffer>, x Expr) 
// Island
func WriteExpr(buf Memory<Buffer>, x Expr) void

Shared Sub WriteExpr(buf As Memory<Buffer>, x As Expr)

class method WriteSignature(buf: Memory<Buffer>; sig: Memory<Signature>; qf: Qualifier)

static void WriteSignature(Memory<Buffer> buf, Memory<Signature> sig, Qualifier qf)

static func WriteSignature(_ buf: Memory<Buffer>, _ sig: Memory<Signature>, _ qf: Qualifier)

// .NET, .NET Standard 2.0
func WriteSignature(buf Memory<Buffer>, sig Memory<Signature>, qf Qualifier) 
// Island
func WriteSignature(buf Memory<Buffer>, sig Memory<Signature>, qf Qualifier) void

Shared Sub WriteSignature(buf As Memory<Buffer>, sig As Memory<Signature>, qf As Qualifier)

class method WriteType(buf: Memory<Buffer>; typ: Type; qf: Qualifier)

static void WriteType(Memory<Buffer> buf, Type typ, Qualifier qf)

static func WriteType(_ buf: Memory<Buffer>, _ typ: Type, _ qf: Qualifier)

// .NET, .NET Standard 2.0
func WriteType(buf Memory<Buffer>, typ Type, qf Qualifier) 
// Island
func WriteType(buf Memory<Buffer>, typ Type, qf Qualifier) void

Shared Sub WriteType(buf As Memory<Buffer>, typ As Type, qf As Qualifier)

const Bool: BasicKind = 1

const BasicKind Bool = 1

static let Bool: BasicKind = 1

const Bool BasicKind = 1

Const Bool As BasicKind = 1

const Byte: BasicKind = 8

const BasicKind Byte = 8

static let Byte: BasicKind = 8

const Byte BasicKind = 8

Const Byte As BasicKind = 8

const Complex128: BasicKind = 16

const BasicKind Complex128 = 16

static let Complex128: BasicKind = 16

const Complex128 BasicKind = 16

Const Complex128 As BasicKind = 16

const Complex64: BasicKind = 15

const BasicKind Complex64 = 15

static let Complex64: BasicKind = 15

const Complex64 BasicKind = 15

Const Complex64 As BasicKind = 15

const FieldVal: SelectionKind = 0

const SelectionKind FieldVal = 0

static let FieldVal: SelectionKind = 0

const FieldVal SelectionKind = 0

Const FieldVal As SelectionKind = 0

const Float32: BasicKind = 13

const BasicKind Float32 = 13

static let Float32: BasicKind = 13

const Float32 BasicKind = 13

Const Float32 As BasicKind = 13

const Float64: BasicKind = 14

const BasicKind Float64 = 14

static let Float64: BasicKind = 14

const Float64 BasicKind = 14

Const Float64 As BasicKind = 14

const Int: BasicKind = 2

const BasicKind Int = 2

static let Int: BasicKind = 2

const Int BasicKind = 2

Const Int As BasicKind = 2

const Int16: BasicKind = 4

const BasicKind Int16 = 4

static let Int16: BasicKind = 4

const Int16 BasicKind = 4

Const Int16 As BasicKind = 4

const Int32: BasicKind = 5

const BasicKind Int32 = 5

static let Int32: BasicKind = 5

const Int32 BasicKind = 5

Const Int32 As BasicKind = 5

const Int64: BasicKind = 6

const BasicKind Int64 = 6

static let Int64: BasicKind = 6

const Int64 BasicKind = 6

Const Int64 As BasicKind = 6

const Int8: BasicKind = 3

const BasicKind Int8 = 3

static let Int8: BasicKind = 3

const Int8 BasicKind = 3

Const Int8 As BasicKind = 3

const Invalid: BasicKind = 0

const BasicKind Invalid = 0

static let Invalid: BasicKind = 0

const Invalid BasicKind = 0

Const Invalid As BasicKind = 0

const IsBoolean: BasicInfo = 1

const BasicInfo IsBoolean = 1

static let IsBoolean: BasicInfo = 1

const IsBoolean BasicInfo = 1

Const IsBoolean As BasicInfo = 1

const IsComplex: BasicInfo = 16

const BasicInfo IsComplex = 16

static let IsComplex: BasicInfo = 16

const IsComplex BasicInfo = 16

Const IsComplex As BasicInfo = 16

const IsConstType: BasicInfo = 59

const BasicInfo IsConstType = 59

static let IsConstType: BasicInfo = 59

const IsConstType BasicInfo = 59

Const IsConstType As BasicInfo = 59

const IsFloat: BasicInfo = 8

const BasicInfo IsFloat = 8

static let IsFloat: BasicInfo = 8

const IsFloat BasicInfo = 8

Const IsFloat As BasicInfo = 8

const IsInteger: BasicInfo = 2

const BasicInfo IsInteger = 2

static let IsInteger: BasicInfo = 2

const IsInteger BasicInfo = 2

Const IsInteger As BasicInfo = 2

const IsNumeric: BasicInfo = 26

const BasicInfo IsNumeric = 26

static let IsNumeric: BasicInfo = 26

const IsNumeric BasicInfo = 26

Const IsNumeric As BasicInfo = 26

const IsOrdered: BasicInfo = 42

const BasicInfo IsOrdered = 42

static let IsOrdered: BasicInfo = 42

const IsOrdered BasicInfo = 42

Const IsOrdered As BasicInfo = 42

const IsString: BasicInfo = 32

const BasicInfo IsString = 32

static let IsString: BasicInfo = 32

const IsString BasicInfo = 32

Const IsString As BasicInfo = 32

const IsUnsigned: BasicInfo = 4

const BasicInfo IsUnsigned = 4

static let IsUnsigned: BasicInfo = 4

const IsUnsigned BasicInfo = 4

Const IsUnsigned As BasicInfo = 4

const IsUntyped: BasicInfo = 64

const BasicInfo IsUntyped = 64

static let IsUntyped: BasicInfo = 64

const IsUntyped BasicInfo = 64

Const IsUntyped As BasicInfo = 64

const MethodExpr: SelectionKind = 2

const SelectionKind MethodExpr = 2

static let MethodExpr: SelectionKind = 2

const MethodExpr SelectionKind = 2

Const MethodExpr As SelectionKind = 2

const MethodVal: SelectionKind = 1

const SelectionKind MethodVal = 1

static let MethodVal: SelectionKind = 1

const MethodVal SelectionKind = 1

Const MethodVal As SelectionKind = 1

const RecvOnly: ChanDir = 2

const ChanDir RecvOnly = 2

static let RecvOnly: ChanDir = 2

const RecvOnly ChanDir = 2

Const RecvOnly As ChanDir = 2

const Rune: BasicKind = 5

const BasicKind Rune = 5

static let Rune: BasicKind = 5

const Rune BasicKind = 5

Const Rune As BasicKind = 5

const SendOnly: ChanDir = 1

const ChanDir SendOnly = 1

static let SendOnly: ChanDir = 1

const SendOnly ChanDir = 1

Const SendOnly As ChanDir = 1

const SendRecv: ChanDir = 0

const ChanDir SendRecv = 0

static let SendRecv: ChanDir = 0

const SendRecv ChanDir = 0

Const SendRecv As ChanDir = 0

const String: BasicKind = 17

const BasicKind String = 17

static let String: BasicKind = 17

const String BasicKind = 17

Const String As BasicKind = 17

const Uint: BasicKind = 7

const BasicKind Uint = 7

static let Uint: BasicKind = 7

const Uint BasicKind = 7

Const Uint As BasicKind = 7

const Uint16: BasicKind = 9

const BasicKind Uint16 = 9

static let Uint16: BasicKind = 9

const Uint16 BasicKind = 9

Const Uint16 As BasicKind = 9

const Uint32: BasicKind = 10

const BasicKind Uint32 = 10

static let Uint32: BasicKind = 10

const Uint32 BasicKind = 10

Const Uint32 As BasicKind = 10

const Uint64: BasicKind = 11

const BasicKind Uint64 = 11

static let Uint64: BasicKind = 11

const Uint64 BasicKind = 11

Const Uint64 As BasicKind = 11

const Uint8: BasicKind = 8

const BasicKind Uint8 = 8

static let Uint8: BasicKind = 8

const Uint8 BasicKind = 8

Const Uint8 As BasicKind = 8

const Uintptr: BasicKind = 12

const BasicKind Uintptr = 12

static let Uintptr: BasicKind = 12

const Uintptr BasicKind = 12

Const Uintptr As BasicKind = 12

const UnsafePointer: BasicKind = 18

const BasicKind UnsafePointer = 18

static let UnsafePointer: BasicKind = 18

const UnsafePointer BasicKind = 18

Const UnsafePointer As BasicKind = 18

const UntypedBool: BasicKind = 19

const BasicKind UntypedBool = 19

static let UntypedBool: BasicKind = 19

const UntypedBool BasicKind = 19

Const UntypedBool As BasicKind = 19

const UntypedComplex: BasicKind = 23

const BasicKind UntypedComplex = 23

static let UntypedComplex: BasicKind = 23

const UntypedComplex BasicKind = 23

Const UntypedComplex As BasicKind = 23

const UntypedFloat: BasicKind = 22

const BasicKind UntypedFloat = 22

static let UntypedFloat: BasicKind = 22

const UntypedFloat BasicKind = 22

Const UntypedFloat As BasicKind = 22

const UntypedInt: BasicKind = 20

const BasicKind UntypedInt = 20

static let UntypedInt: BasicKind = 20

const UntypedInt BasicKind = 20

Const UntypedInt As BasicKind = 20

const UntypedNil: BasicKind = 25

const BasicKind UntypedNil = 25

static let UntypedNil: BasicKind = 25

const UntypedNil BasicKind = 25

Const UntypedNil As BasicKind = 25

const UntypedRune: BasicKind = 21

const BasicKind UntypedRune = 21

static let UntypedRune: BasicKind = 21

const UntypedRune BasicKind = 21

Const UntypedRune As BasicKind = 21

const UntypedString: BasicKind = 24

const BasicKind UntypedString = 24

static let UntypedString: BasicKind = 24

const UntypedString BasicKind = 24

Const UntypedString As BasicKind = 24

class var Typ: Slice<Memory<Basic>>;

static Slice<Memory<Basic>> Typ

static var Typ: Slice<Memory<Basic>>

Typ Slice<Memory<Basic>>

Shared FIELD Typ() As Slice<Memory<Basic>>

class var Universe: Memory<Scope>;

static Memory<Scope> Universe

static var Universe: Memory<Scope>

Universe Memory<Scope>

Shared FIELD Universe() As Memory<Scope>

class var Unsafe: Memory<Package>;

static Memory<Package> Unsafe

static var Unsafe: Memory<Package>

Unsafe Memory<Package>

Shared FIELD Unsafe() As Memory<Package>

class method AssertableTo(V: Memory<Interface>; T: Type): bool

static bool AssertableTo(Memory<Interface> V, Type T)

static func AssertableTo(_ V: Memory<Interface>, _ T: Type) -> bool

func AssertableTo(V Memory<Interface>, T Type) bool

Shared Function AssertableTo(V As Memory<Interface>, T As Type) As bool

class method AssignableTo(V: Type; T: Type): bool

static bool AssignableTo(Type V, Type T)

static func AssignableTo(_ V: Type, _ T: Type) -> bool

func AssignableTo(V Type, T Type) bool

Shared Function AssignableTo(V As Type, T As Type) As bool

class method CheckExpr(fset: Memory<FileSet>; pkg: Memory<Package>; pos: Pos; expr: Expr; info: Memory<Info>): error

static error CheckExpr(Memory<FileSet> fset, Memory<Package> pkg, Pos pos, Expr expr, Memory<Info> info)

static func CheckExpr(_ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ pos: Pos, _ expr: Expr, _ info: Memory<Info>) -> error

func CheckExpr(fset Memory<FileSet>, pkg Memory<Package>, pos Pos, expr Expr, info Memory<Info>) error

Shared Function CheckExpr(fset As Memory<FileSet>, pkg As Memory<Package>, pos As Pos, expr As Expr, info As Memory<Info>) As error

class method Comparable(T: Type): bool

static bool Comparable(Type T)

static func Comparable(_ T: Type) -> bool

func Comparable(T Type) bool

Shared Function Comparable(T As Type) As bool

class method ConvertibleTo(V: Type; T: Type): bool

static bool ConvertibleTo(Type V, Type T)

static func ConvertibleTo(_ V: Type, _ T: Type) -> bool

func ConvertibleTo(V Type, T Type) bool

Shared Function ConvertibleTo(V As Type, T As Type) As bool

class method Default(typ: Type): Type

static Type Default(Type typ)

static func Default(_ typ: Type) -> Type

func Default(typ Type) Type

Shared Function Default(typ As Type) As Type

class method DefPredeclaredTestFuncs

static void DefPredeclaredTestFuncs()

static func DefPredeclaredTestFuncs()

// .NET, .NET Standard 2.0
func DefPredeclaredTestFuncs() 
// Island
func DefPredeclaredTestFuncs() void

Shared Sub DefPredeclaredTestFuncs()

class method Eval(fset: Memory<FileSet>; pkg: Memory<Package>; pos: Pos; expr: string): tuple of (_: TypeAndValue, err: error)

static (TypeAndValue _, error err) Eval(Memory<FileSet> fset, Memory<Package> pkg, Pos pos, string expr)

static func Eval(_ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ pos: Pos, _ expr: string) -> tuple of (TypeAndValue, error)

func Eval(fset Memory<FileSet>, pkg Memory<Package>, pos Pos, expr string) tuple of (|name=_| TypeAndValue, |name=err| error)

Shared Function Eval(fset As Memory<FileSet>, pkg As Memory<Package>, pos As Pos, expr As string) As Tuple (Of TypeAndValue, error)

class method ExprString(x: Expr): string

static string ExprString(Expr x)

static func ExprString(_ x: Expr) -> string

func ExprString(x Expr) string

Shared Function ExprString(x As Expr) As string

class method Id(pkg: Memory<Package>; name: string): string

static string Id(Memory<Package> pkg, string name)

static func Id(_ pkg: Memory<Package>, _ name: string) -> string

func Id(pkg Memory<Package>, name string) string

Shared Function Id(pkg As Memory<Package>, name As string) As string

class method Identical(x: Type; y: Type): bool

static bool Identical(Type x, Type y)

static func Identical(_ x: Type, _ y: Type) -> bool

func Identical(x Type, y Type) bool

Shared Function Identical(x As Type, y As Type) As bool

class method IdenticalIgnoreTags(x: Type; y: Type): bool

static bool IdenticalIgnoreTags(Type x, Type y)

static func IdenticalIgnoreTags(_ x: Type, _ y: Type) -> bool

func IdenticalIgnoreTags(x Type, y Type) bool

Shared Function IdenticalIgnoreTags(x As Type, y As Type) As bool

class method Implements(V: Type; T: Memory<Interface>): bool

static bool Implements(Type V, Memory<Interface> T)

static func Implements(_ V: Type, _ T: Memory<Interface>) -> bool

func Implements(V Type, T Memory<Interface>) bool

Shared Function Implements(V As Type, T As Memory<Interface>) As bool

class method IsInterface(typ: Type): bool

static bool IsInterface(Type typ)

static func IsInterface(_ typ: Type) -> bool

func IsInterface(typ Type) bool

Shared Function IsInterface(typ As Type) As bool

class method LookupFieldOrMethod(T: Type; addressable: bool; pkg: Memory<Package>; name: string): tuple of (obj: Object, index: Slice<Int64>, indirect: Boolean)

static (Object obj, Slice<Int64>index, Boolean indirect) LookupFieldOrMethod(Type T, bool addressable, Memory<Package> pkg, string name)

static func LookupFieldOrMethod(_ T: Type, _ addressable: bool, _ pkg: Memory<Package>, _ name: string) -> tuple of (Object, Slice<Int64>, Boolean)

func LookupFieldOrMethod(T Type, addressable bool, pkg Memory<Package>, name string) tuple of (|name=obj| Object, |name=index| Slice<Int64>, |name=indirect| Boolean)

Shared Function LookupFieldOrMethod(T As Type, addressable As bool, pkg As Memory<Package>, name As string) As Tuple (Of Object, Slice<Int64>, Boolean)

class method MissingMethod(V: Type; T: Memory<Interface>; static: bool): tuple of (method: Memory<Func>, wrongType: Boolean)

static (Memory<Func>method, Boolean wrongType) MissingMethod(Type V, Memory<Interface> T, bool static)

static func MissingMethod(_ V: Type, _ T: Memory<Interface>, _ static: bool) -> tuple of (Memory<Func>, Boolean)

func MissingMethod(V Type, T Memory<Interface>, static bool) tuple of (|name=method| Memory<Func>, |name=wrongType| Boolean)

Shared Function MissingMethod(V As Type, T As Memory<Interface>, static As bool) As Tuple (Of Memory<Func>, Boolean)

class method NewArray(elem: Type; len: int64): Memory<Array>

static Memory<Array> NewArray(Type elem, int64 len)

static func NewArray(_ elem: Type, _ len: int64) -> Memory<Array>

func NewArray(elem Type, len int64) Memory<Array>

Shared Function NewArray(elem As Type, len As int64) As Memory<Array>

class method NewChan(dir: ChanDir; elem: Type): Memory<Chan>

static Memory<Chan> NewChan(ChanDir dir, Type elem)

static func NewChan(_ dir: ChanDir, _ elem: Type) -> Memory<Chan>

func NewChan(dir ChanDir, elem Type) Memory<Chan>

Shared Function NewChan(dir As ChanDir, elem As Type) As Memory<Chan>

class method NewChecker(conf: Memory<Config>; fset: Memory<FileSet>; pkg: Memory<Package>; info: Memory<Info>): Memory<Checker>

static Memory<Checker> NewChecker(Memory<Config> conf, Memory<FileSet> fset, Memory<Package> pkg, Memory<Info> info)

static func NewChecker(_ conf: Memory<Config>, _ fset: Memory<FileSet>, _ pkg: Memory<Package>, _ info: Memory<Info>) -> Memory<Checker>

func NewChecker(conf Memory<Config>, fset Memory<FileSet>, pkg Memory<Package>, info Memory<Info>) Memory<Checker>

Shared Function NewChecker(conf As Memory<Config>, fset As Memory<FileSet>, pkg As Memory<Package>, info As Memory<Info>) As Memory<Checker>

class method NewConst(pos: Pos; pkg: Memory<Package>; name: string; typ: Type; val: Value): Memory<Const>

static Memory<Const> NewConst(Pos pos, Memory<Package> pkg, string name, Type typ, Value val)

static func NewConst(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type, _ val: Value) -> Memory<Const>

func NewConst(pos Pos, pkg Memory<Package>, name string, typ Type, val Value) Memory<Const>

Shared Function NewConst(pos As Pos, pkg As Memory<Package>, name As string, typ As Type, val As Value) As Memory<Const>

class method NewField(pos: Pos; pkg: Memory<Package>; name: string; typ: Type; embedded: bool): Memory<Var>

static Memory<Var> NewField(Pos pos, Memory<Package> pkg, string name, Type typ, bool embedded)

static func NewField(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type, _ embedded: bool) -> Memory<Var>

func NewField(pos Pos, pkg Memory<Package>, name string, typ Type, embedded bool) Memory<Var>

Shared Function NewField(pos As Pos, pkg As Memory<Package>, name As string, typ As Type, embedded As bool) As Memory<Var>

class method NewFunc(pos: Pos; pkg: Memory<Package>; name: string; sig: Memory<Signature>): Memory<Func>

static Memory<Func> NewFunc(Pos pos, Memory<Package> pkg, string name, Memory<Signature> sig)

static func NewFunc(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ sig: Memory<Signature>) -> Memory<Func>

func NewFunc(pos Pos, pkg Memory<Package>, name string, sig Memory<Signature>) Memory<Func>

Shared Function NewFunc(pos As Pos, pkg As Memory<Package>, name As string, sig As Memory<Signature>) As Memory<Func>

class method NewInterface(methods: Slice<Memory<Func>>; embeddeds: Slice<Memory<Named>>): Memory<Interface>

static Memory<Interface> NewInterface(Slice<Memory<Func>> methods, Slice<Memory<Named>> embeddeds)

static func NewInterface(_ methods: Slice<Memory<Func>>, _ embeddeds: Slice<Memory<Named>>) -> Memory<Interface>

func NewInterface(methods Slice<Memory<Func>>, embeddeds Slice<Memory<Named>>) Memory<Interface>

Shared Function NewInterface(methods As Slice<Memory<Func>>, embeddeds As Slice<Memory<Named>>) As Memory<Interface>

class method NewInterfaceType(methods: Slice<Memory<Func>>; embeddeds: Slice<Type>): Memory<Interface>

static Memory<Interface> NewInterfaceType(Slice<Memory<Func>> methods, Slice<Type> embeddeds)

static func NewInterfaceType(_ methods: Slice<Memory<Func>>, _ embeddeds: Slice<Type>) -> Memory<Interface>

func NewInterfaceType(methods Slice<Memory<Func>>, embeddeds Slice<Type>) Memory<Interface>

Shared Function NewInterfaceType(methods As Slice<Memory<Func>>, embeddeds As Slice<Type>) As Memory<Interface>

class method NewLabel(pos: Pos; pkg: Memory<Package>; name: string): Memory<Label>

static Memory<Label> NewLabel(Pos pos, Memory<Package> pkg, string name)

static func NewLabel(_ pos: Pos, _ pkg: Memory<Package>, _ name: string) -> Memory<Label>

func NewLabel(pos Pos, pkg Memory<Package>, name string) Memory<Label>

Shared Function NewLabel(pos As Pos, pkg As Memory<Package>, name As string) As Memory<Label>

class method NewMap(key: Type; elem: Type): Memory<Map>

static Memory<Map> NewMap(Type key, Type elem)

static func NewMap(_ key: Type, _ elem: Type) -> Memory<Map>

func NewMap(key Type, elem Type) Memory<Map>

Shared Function NewMap(key As Type, elem As Type) As Memory<Map>

class method NewMethodSet(T: Type): Memory<MethodSet>

static Memory<MethodSet> NewMethodSet(Type T)

static func NewMethodSet(_ T: Type) -> Memory<MethodSet>

func NewMethodSet(T Type) Memory<MethodSet>

Shared Function NewMethodSet(T As Type) As Memory<MethodSet>

class method NewNamed(obj: Memory<TypeName>; underlying: Type; methods: Slice<Memory<Func>>): Memory<Named>

static Memory<Named> NewNamed(Memory<TypeName> obj, Type underlying, Slice<Memory<Func>> methods)

static func NewNamed(_ obj: Memory<TypeName>, _ underlying: Type, _ methods: Slice<Memory<Func>>) -> Memory<Named>

func NewNamed(obj Memory<TypeName>, underlying Type, methods Slice<Memory<Func>>) Memory<Named>

Shared Function NewNamed(obj As Memory<TypeName>, underlying As Type, methods As Slice<Memory<Func>>) As Memory<Named>

class method NewPackage(path: string; name: string): Memory<Package>

static Memory<Package> NewPackage(string path, string name)

static func NewPackage(_ path: string, _ name: string) -> Memory<Package>

func NewPackage(path string, name string) Memory<Package>

Shared Function NewPackage(path As string, name As string) As Memory<Package>

class method NewParam(pos: Pos; pkg: Memory<Package>; name: string; typ: Type): Memory<Var>

static Memory<Var> NewParam(Pos pos, Memory<Package> pkg, string name, Type typ)

static func NewParam(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type) -> Memory<Var>

func NewParam(pos Pos, pkg Memory<Package>, name string, typ Type) Memory<Var>

Shared Function NewParam(pos As Pos, pkg As Memory<Package>, name As string, typ As Type) As Memory<Var>

class method NewPkgName(pos: Pos; pkg: Memory<Package>; name: string; imported: Memory<Package>): Memory<PkgName>

static Memory<PkgName> NewPkgName(Pos pos, Memory<Package> pkg, string name, Memory<Package> imported)

static func NewPkgName(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ imported: Memory<Package>) -> Memory<PkgName>

func NewPkgName(pos Pos, pkg Memory<Package>, name string, imported Memory<Package>) Memory<PkgName>

Shared Function NewPkgName(pos As Pos, pkg As Memory<Package>, name As string, imported As Memory<Package>) As Memory<PkgName>

class method NewPointer(elem: Type): Memory<Pointer>

static Memory<Pointer> NewPointer(Type elem)

static func NewPointer(_ elem: Type) -> Memory<Pointer>

func NewPointer(elem Type) Memory<Pointer>

Shared Function NewPointer(elem As Type) As Memory<Pointer>

class method NewScope(parent: Memory<Scope>; pos: Pos; end: Pos; comment: string): Memory<Scope>

static Memory<Scope> NewScope(Memory<Scope> parent, Pos pos, Pos end, string comment)

static func NewScope(_ parent: Memory<Scope>, _ pos: Pos, _ end: Pos, _ comment: string) -> Memory<Scope>

func NewScope(parent Memory<Scope>, pos Pos, end Pos, comment string) Memory<Scope>

Shared Function NewScope(parent As Memory<Scope>, pos As Pos, end As Pos, comment As string) As Memory<Scope>

class method NewSignature(recv: Memory<Var>; params: Memory<Tuple>; results: Memory<Tuple>; variadic: bool): Memory<Signature>

static Memory<Signature> NewSignature(Memory<Var> recv, Memory<Tuple> params, Memory<Tuple> results, bool variadic)

static func NewSignature(_ recv: Memory<Var>, _ params: Memory<Tuple>, _ results: Memory<Tuple>, _ variadic: bool) -> Memory<Signature>

func NewSignature(recv Memory<Var>, params Memory<Tuple>, results Memory<Tuple>, variadic bool) Memory<Signature>

Shared Function NewSignature(recv As Memory<Var>, params As Memory<Tuple>, results As Memory<Tuple>, variadic As bool) As Memory<Signature>

class method NewSlice(elem: Type): Memory<Slice>

static Memory<Slice> NewSlice(Type elem)

static func NewSlice(_ elem: Type) -> Memory<Slice>

func NewSlice(elem Type) Memory<Slice>

Shared Function NewSlice(elem As Type) As Memory<Slice>

class method NewStruct(fields: Slice<Memory<Var>>; tags: Slice<string>): Memory<Struct>

static Memory<Struct> NewStruct(Slice<Memory<Var>> fields, Slice<string> tags)

static func NewStruct(_ fields: Slice<Memory<Var>>, _ tags: Slice<string>) -> Memory<Struct>

func NewStruct(fields Slice<Memory<Var>>, tags Slice<string>) Memory<Struct>

Shared Function NewStruct(fields As Slice<Memory<Var>>, tags As Slice<string>) As Memory<Struct>

class method NewTuple(params x: array of Memory<Var>): Memory<Tuple>

static Memory<Tuple> NewTuple(params Memory<Var>[] x)

static func NewTuple(_ x: Memory<Var>...) -> Memory<Tuple>

func NewTuple(x []Memory<Var>) Memory<Tuple>

Shared Function NewTuple(ParamArray x As Memory<Var>()) As Memory<Tuple>

class method NewTypeName(pos: Pos; pkg: Memory<Package>; name: string; typ: Type): Memory<TypeName>

static Memory<TypeName> NewTypeName(Pos pos, Memory<Package> pkg, string name, Type typ)

static func NewTypeName(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type) -> Memory<TypeName>

func NewTypeName(pos Pos, pkg Memory<Package>, name string, typ Type) Memory<TypeName>

Shared Function NewTypeName(pos As Pos, pkg As Memory<Package>, name As string, typ As Type) As Memory<TypeName>

class method NewVar(pos: Pos; pkg: Memory<Package>; name: string; typ: Type): Memory<Var>

static Memory<Var> NewVar(Pos pos, Memory<Package> pkg, string name, Type typ)

static func NewVar(_ pos: Pos, _ pkg: Memory<Package>, _ name: string, _ typ: Type) -> Memory<Var>

func NewVar(pos Pos, pkg Memory<Package>, name string, typ Type) Memory<Var>

Shared Function NewVar(pos As Pos, pkg As Memory<Package>, name As string, typ As Type) As Memory<Var>

class method ObjectString(obj: Object; qf: Qualifier): string

static string ObjectString(Object obj, Qualifier qf)

static func ObjectString(_ obj: Object, _ qf: Qualifier) -> string

func ObjectString(obj Object, qf Qualifier) string

Shared Function ObjectString(obj As Object, qf As Qualifier) As string

class method RelativeTo(pkg: Memory<Package>): Qualifier

static Qualifier RelativeTo(Memory<Package> pkg)

static func RelativeTo(_ pkg: Memory<Package>) -> Qualifier

func RelativeTo(pkg Memory<Package>) Qualifier

Shared Function RelativeTo(pkg As Memory<Package>) As Qualifier

class method SelectionString(s: Memory<Selection>; qf: Qualifier): string

static string SelectionString(Memory<Selection> s, Qualifier qf)

static func SelectionString(_ s: Memory<Selection>, _ qf: Qualifier) -> string

func SelectionString(s Memory<Selection>, qf Qualifier) string

Shared Function SelectionString(s As Memory<Selection>, qf As Qualifier) As string

class method SizesFor(compiler: string; arch: string): Sizes

static Sizes SizesFor(string compiler, string arch)

static func SizesFor(_ compiler: string, _ arch: string) -> Sizes

func SizesFor(compiler string, arch string) Sizes

Shared Function SizesFor(compiler As string, arch As string) As Sizes

class method TypeString(typ: Type; qf: Qualifier): string

static string TypeString(Type typ, Qualifier qf)

static func TypeString(_ typ: Type, _ qf: Qualifier) -> string

func TypeString(typ Type, qf Qualifier) string

Shared Function TypeString(typ As Type, qf As Qualifier) As string

class method WriteExpr(buf: Memory<Buffer>; x: Expr)

static void WriteExpr(Memory<Buffer> buf, Expr x)

static func WriteExpr(_ buf: Memory<Buffer>, _ x: Expr)

// .NET, .NET Standard 2.0
func WriteExpr(buf Memory<Buffer>, x Expr) 
// Island
func WriteExpr(buf Memory<Buffer>, x Expr) void

Shared Sub WriteExpr(buf As Memory<Buffer>, x As Expr)

class method WriteSignature(buf: Memory<Buffer>; sig: Memory<Signature>; qf: Qualifier)

static void WriteSignature(Memory<Buffer> buf, Memory<Signature> sig, Qualifier qf)

static func WriteSignature(_ buf: Memory<Buffer>, _ sig: Memory<Signature>, _ qf: Qualifier)

// .NET, .NET Standard 2.0
func WriteSignature(buf Memory<Buffer>, sig Memory<Signature>, qf Qualifier) 
// Island
func WriteSignature(buf Memory<Buffer>, sig Memory<Signature>, qf Qualifier) void

Shared Sub WriteSignature(buf As Memory<Buffer>, sig As Memory<Signature>, qf As Qualifier)

class method WriteType(buf: Memory<Buffer>; typ: Type; qf: Qualifier)

static void WriteType(Memory<Buffer> buf, Type typ, Qualifier qf)

static func WriteType(_ buf: Memory<Buffer>, _ typ: Type, _ qf: Qualifier)

// .NET, .NET Standard 2.0
func WriteType(buf Memory<Buffer>, typ Type, qf Qualifier) 
// Island
func WriteType(buf Memory<Buffer>, typ Type, qf Qualifier) void

Shared Sub WriteType(buf As Memory<Buffer>, typ As Type, qf As Qualifier)