types

package
v1.23.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 14, 2024 License: MIT Imports: 7 Imported by: 0

Documentation

Overview

typesパッケージは、Goパッケージの型チェックのためのアルゴリズムを実装し、 データ型を宣言します。Config.Check を使用してパッケージの型チェッカーを呼び出すか、 代わりに NewChecker で新しい型チェッカーを作成し、Checker.Files を呼び出して インクリメンタルに呼び出すことができます。

型チェックは、いくつかの相互依存するフェーズで構成されています。

名前解決は、プログラム内の各識別子(ast.Ident)を、それが示すシンボル(Object)にマッピングします。 識別子のシンボルを見つけるには、Info のDefsフィールドとUsesフィールド、または Info.ObjectOf メソッドを使用します。 そして、特定の他の種類の構文ノードのシンボルを見つけるには、Info のImplicitsフィールドを使用します。

定数畳み込みは、コンパイル時定数であるすべての式(ast.Expr)の正確な定数値 (constant.Value)を計算します。式の定数畳み込みの結果を見つけるには、Info のTypesフィールドを使用します。

型推論は、すべての式(ast.Expr)の型(Type)を計算し、言語仕様に準拠しているかをチェックします。 型推論の結果については、[Info]のTypesフィールドを使用してください。

チュートリアルについては、https://go.dev/s/types-tutorial を参照してください。

Index

Examples

Constants

This section is empty.

Variables

View Source 
var Typ = []*Basic{
	Invalid: {Invalid, 0, "invalid type"},

	Bool:          {Bool, IsBoolean, "bool"},
	Int:           {Int, IsInteger, "int"},
	Int8:          {Int8, IsInteger, "int8"},
	Int16:         {Int16, IsInteger, "int16"},
	Int32:         {Int32, IsInteger, "int32"},
	Int64:         {Int64, IsInteger, "int64"},
	Uint:          {Uint, IsInteger | IsUnsigned, "uint"},
	Uint8:         {Uint8, IsInteger | IsUnsigned, "uint8"},
	Uint16:        {Uint16, IsInteger | IsUnsigned, "uint16"},
	Uint32:        {Uint32, IsInteger | IsUnsigned, "uint32"},
	Uint64:        {Uint64, IsInteger | IsUnsigned, "uint64"},
	Uintptr:       {Uintptr, IsInteger | IsUnsigned, "uintptr"},
	Float32:       {Float32, IsFloat, "float32"},
	Float64:       {Float64, IsFloat, "float64"},
	Complex64:     {Complex64, IsComplex, "complex64"},
	Complex128:    {Complex128, IsComplex, "complex128"},
	String:        {String, IsString, "string"},
	UnsafePointer: {UnsafePointer, 0, "Pointer"},

	UntypedBool:    {UntypedBool, IsBoolean | IsUntyped, "untyped bool"},
	UntypedInt:     {UntypedInt, IsInteger | IsUntyped, "untyped int"},
	UntypedRune:    {UntypedRune, IsInteger | IsUntyped, "untyped rune"},
	UntypedFloat:   {UntypedFloat, IsFloat | IsUntyped, "untyped float"},
	UntypedComplex: {UntypedComplex, IsComplex | IsUntyped, "untyped complex"},
	UntypedString:  {UntypedString, IsString | IsUntyped, "untyped string"},
	UntypedNil:     {UntypedNil, IsUntyped, "untyped nil"},
}

Typは、それぞれのBasicKindによってインデックス付けされた事前宣言された*Basic型を含んでいます。

Typ[Byte]の*Basic型は、名前が「uint8」になります。 「byte」という特定のエイリアスの基本型を取得するには、Universe.Lookup("byte").Type()を使用します（また、「rune」に対しても同様です）。

Functions

func AssertableTo 

func AssertableTo(V *Interface, T Type) bool

AssertableToは、型Vの値が型Tにアサートされることができるかどうかを報告します。

AssertableToの動作は、3つのケースで未指定です：

  • TがTyp[Invalid]である場合
  • Vが一般化されたインタフェースである場合。つまり、Goコードで型制約としてのみ使用されるインタフェースである場合
  • Tが未実体化のジェネリック型である場合

func AssignableTo 

func AssignableTo(V, T Type) bool

AssignableToは、型Vの値が型Tの変数に代入可能かどうかを報告します。

AssignableToの動作は、VまたはTがTyp[Invalid]またはインスタンス化されていないジェネリック型の場合、指定されていません。

func CheckExpr added in v1.13.0 

func CheckExpr(fset *token.FileSet, pkg *Package, pos token.Pos, expr ast.Expr, info *Info) (err error)

CheckExprは、式exprがパッケージpkgの位置posに現れたかのように型チェックを行います。 式についての Type 情報はinfoに記録されます。式は、実体化されていないジェネリック関数や型を示す識別子である場合があります。

pkg == nilの場合、Universe のスコープが使用され、指定された位置posは無視されます。 pkg != nilであり、posが無効な場合、パッケージのスコープが使用されます。それ以外の場合、posはパッケージに属している必要があります。

posがパッケージ内にない場合や、ノードが型チェックできない場合はエラーが返されます。

注意: Eval とCheckExprは、型と値を計算するためにCheckを実行する代わりに使用するべきではありませんが、Checkに追加して使用する必要があります。 これらの関数は式が使用される文脈（例: 代入）を無視するため、トップレベルの未型付き定数は対応する文脈固有の型ではなく、未型付きの型を返します。

func Comparable 

func Comparable(T Type) bool

Comparableは、型Tの値が比較可能かどうかを報告します。

func ConvertibleTo 

func ConvertibleTo(V, T Type) bool

ConvertibleToは、型Vの値が型Tの値に変換可能かどうかを報告します。

ConvertibleToの動作は、VまたはTがTyp[Invalid]またはインスタンス化されていないジェネリック型である場合、指定されていません。

func DefPredeclaredTestFuncs 

func DefPredeclaredTestFuncs()

DefPredeclaredTestFuncsは、assertとtraceのビルトイン関数を定義します。 これらのビルトイン関数は、このパッケージのデバッグとテストのために作られています。

func ExprString 

func ExprString(x ast.Expr) string

ExprStringはxの（短縮された可能性のある）文字列表現を返します。 短縮された表現はユーザーインターフェースに適していますが、Goの構文に必ずしも従っているわけではありません。

func Id 

func Id(pkg *Package, name string) string

Idが公開されていれば、そのままの名前を返します。それ以外の場合は、 パッケージのパスで修飾された名前を返します。

func Identical 

func Identical(x, y Type) bool

Identicalはxとyが同じ型であるかどうかを返します。 Signature 型のレシーバは無視されます。

Identical、Implements、Satisfies などの述語は、 両方のオペランドが一貫したシンボルのコレクション（Object 値）に属していると仮定します。 例えば、2つの Named 型は、それらの Named.Obj メソッドが同じ TypeName シンボルを返す場合にのみ同一となります。 シンボルのコレクションが一貫しているとは、パスがPである各論理パッケージについて、 それらのシンボルの作成には最大で一回の NewPackage(P, ...)の呼び出しが関与していることを意味します。 一貫性を確保するために、すべてのロードされたパッケージとその依存関係に対して単一の Importer を使用します。 詳細は https://github.com/golang/go/issues/57497 を参照してください。

func IdenticalIgnoreTags added in v1.8.0 

func IdenticalIgnoreTags(x, y Type) bool

IdenticalIgnoreTagsは、タグを無視した場合にxとyが同じ型であるかどうかを報告します。 Signature 型のレシーバーは無視されます。

func Implements 

func Implements(V Type, T *Interface) bool

Implementsは、型VがインターフェースTを実装しているかどうかを報告します。

VがTyp[Invalid]やインスタンス化されていないジェネリック型の場合、Implementsの動作は未指定です。

func IsInterface 

func IsInterface(t Type) bool

IsInterfaceはtがインターフェース型かどうかを報告します。

func ObjectString 

func ObjectString(obj Object, qf Qualifier) string

ObjectStringはobjの文字列形式を返します。 Qualifierはパッケージレベルのオブジェクトの印刷を制御し、nilである可能性があります。

func Satisfies added in v1.20.0 

func Satisfies(V Type, T *Interface) bool

Satisfiesは型Vが制約Tを満たすかどうかを報告します。

VがTyp[Invalid]またはインスタンス化されていないジェネリック型である場合、Satisfiesの動作は指定されていません。

func SelectionString 

func SelectionString(s *Selection, qf Qualifier) string

SelectionStringはsの文字列形式を返します。 Qualifierはパッケージレベルのオブジェクトの出力を制御し、nilである場合もあります。

例： 

"field (T) f int"
"method (T) f(X) Y"
"method expr (T) f(X) Y"

func TypeString 

func TypeString(typ Type, qf Qualifier) string

TypeStringはtypの文字列表現を返します。 Qualifier はパッケージレベルのオブジェクトの印刷を制御し、nilである可能性があります。

func WriteExpr 

func WriteExpr(buf *bytes.Buffer, x ast.Expr)

WriteExprは、xの（短縮されたかもしれない）文字列表現をbufに書き込みます。 短縮表示はユーザーインターフェースに適していますが、必ずしもGoの構文に従うとは限りません。

func WriteSignature 

func WriteSignature(buf *bytes.Buffer, sig *Signature, qf Qualifier)

WriteSignatureは、関数キーワードを付けずにシグネチャsigの表現をbufに書き込みます。 Qualifier はパッケージレベルのオブジェクトの印刷を制御し、nilである可能性があります。

func WriteType 

func WriteType(buf *bytes.Buffer, typ Type, qf Qualifier)

WriteTypeはtypの文字列表現をbufに書き込みます。 Qualifier はpackageレベルのオブジェクトの表示を制御し、nilであることもあります。

Types

type Alias added in v1.22.0 

type Alias struct {
	// contains filtered or unexported fields
}

Aliasは、エイリアス型を表します。 エイリアス型が作成されるかどうかは、 GODEBUG環境変数のgotypesalias設定によって制御されます。 gotypesalias=1の場合、エイリアス宣言はエイリアス型を生成します。 それ以外の場合、エイリアス情報は型名にのみ存在し、 実際の（エイリアスされた）型を直接指します。

func NewAlias added in v1.22.0 

func NewAlias(obj *TypeName, rhs Type) *Alias

NewAliasは、指定された型名とrhsを持つ新しいAlias型を作成します。 rhsはnilであってはなりません。

func (*Alias) Obj added in v1.22.0 

func (a *Alias) Obj() *TypeName

Obj returns the type name for the declaration defining the alias type a. For instantiated types, this is same as the type name of the origin type.

func (*Alias) Origin added in v1.23.0 

func (a *Alias) Origin() *Alias

Originは、aがインスタンスであるジェネリックエイリアス型を返します。 もしaがジェネリックエイリアスのインスタンスでない場合、Originはaを返します。

func (*Alias) Rhs added in v1.23.0 

func (a *Alias) Rhs() Type

Rhsは、エイリアス宣言 "type A = R" の右辺にある型Rを返します。 これは別のエイリアスかもしれません。

func (*Alias) SetTypeParams added in v1.23.0 

func (a *Alias) SetTypeParams(tparams []*TypeParam)

SetTypeParamsは、エイリアス型aの型パラメータを設定します。 エイリアスaは、型引数を持っていてはいけません。

func (*Alias) String added in v1.22.0 

func (a *Alias) String() string

func (*Alias) TypeArgs added in v1.23.0 

func (a *Alias) TypeArgs() *TypeList

TypeArgsは、エイリアス型をインスタンス化するために使用された型引数を返します。 もしaがジェネリックエイリアスのインスタンスでない場合、結果はnilです。

func (*Alias) TypeParams added in v1.23.0 

func (a *Alias) TypeParams() *TypeParamList

TypeParamsは、エイリアス型aの型パラメータを返します。またはnilを返します。 ジェネリックエイリアスとそのインスタンスは、同じ型パラメータを持ちます。

func (*Alias) Underlying added in v1.22.0 

func (a *Alias) Underlying() Type

Underlyingは、エイリアス型aの underlying type を返します。これはエイリアスされた型の基底型です。 基底型は、Named、TypeParam、Alias型ではありません。

type ArgumentError added in v1.18.0 

type ArgumentError struct {
	Index int
	Err   error
}

ArgumentErrorは引数のインデックスに関連するエラーを保持します。

func (*ArgumentError) Error added in v1.18.0 

func (e *ArgumentError) Error() string

func (*ArgumentError) Unwrap added in v1.18.0 

func (e *ArgumentError) Unwrap() error

type Array 

type Array struct {
	// contains filtered or unexported fields
}

Arrayは配列型を表します。

func NewArray 

func NewArray(elem Type, len int64) *Array

NewArrayは指定された要素の型と長さに対して新しい配列型を返します。 負の長さは未知の長さを示します。

func (*Array) Elem 

func (a *Array) Elem() Type

Elemは配列aの要素型を返します。

func (*Array) Len 

func (a *Array) Len() int64

Lenは配列aの長さを返します。 負の結果は、不明な長さを示します。

func (*Array) String 

func (a *Array) String() string

func (*Array) Underlying 

func (a *Array) Underlying() Type

type Basic 

type Basic struct {
	// contains filtered or unexported fields
}

Basicは基本型を表します。

func (*Basic) Info 

func (b *Basic) Info() BasicInfo

Infoは基本型bのプロパティに関する情報を返します。

func (*Basic) Kind 

func (b *Basic) Kind() BasicKind

Kindは基本型bの種類を返します。

func (*Basic) Name 

func (b *Basic) Name() string

Nameは基本型bの名前を返します。

func (*Basic) String 

func (b *Basic) String() string

func (*Basic) Underlying 

func (b *Basic) Underlying() Type

type BasicInfo 

type BasicInfo int

BasicInfoは基本型のプロパティを記述するフラグの集合です。 

const (
	IsBoolean BasicInfo = 1 << iota
	IsInteger
	IsUnsigned
	IsFloat
	IsComplex
	IsString
	IsUntyped

	IsOrdered   = IsInteger | IsFloat | IsString
	IsNumeric   = IsInteger | IsFloat | IsComplex
	IsConstType = IsBoolean | IsNumeric | IsString
)

基本型のプロパティ。

type BasicKind 

type BasicKind int

BasicKindは基本型の種類を表します。 

const (
	Invalid BasicKind = iota

	// 事前に宣言された型
	Bool
	Int
	Int8
	Int16
	Int32
	Int64
	Uint
	Uint8
	Uint16
	Uint32
	Uint64
	Uintptr
	Float32
	Float64
	Complex64
	Complex128
	String
	UnsafePointer

	// 型のない値に対する型
	UntypedBool
	UntypedInt
	UntypedRune
	UntypedFloat
	UntypedComplex
	UntypedString
	UntypedNil

	// エイリアス
	Byte = Uint8
	Rune = Int32
)

type Builtin 

type Builtin struct {
	// contains filtered or unexported fields
}

Builtinは組み込み関数を表します。 組み込み関数には有効な型はありません。

func (*Builtin) String 

func (obj *Builtin) String() string

type Chan 

type Chan struct {
	// contains filtered or unexported fields
}

Chanはチャネルの型を表します。

func NewChan 

func NewChan(dir ChanDir, elem Type) *Chan

NewChanは指定された方向と要素の型のための新しいチャネル型を返します。

func (*Chan) Dir 

func (c *Chan) Dir() ChanDir

Dir 関数は、チャネル c の方向を返します。

func (*Chan) Elem 

func (c *Chan) Elem() Type

Elem はチャネル c の要素の型を返します。

func (*Chan) String 

func (c *Chan) String() string

func (*Chan) Underlying 

func (c *Chan) Underlying() Type

type ChanDir 

type ChanDir int

ChanDirの値は、チャネルの方向を示します。 

const (
	SendRecv ChanDir = iota
	SendOnly
	RecvOnly
)

チャネルの方向は、次の定数のいずれかで示されます。

type Checker 

type Checker struct {
	*Info
	// contains filtered or unexported fields
}

Checkerは型チェッカーの状態を維持します。 NewChecker で作成する必要があります。

func NewChecker 

func NewChecker(conf *Config, fset *token.FileSet, pkg *Package, info *Info) *Checker

NewCheckerは指定されたパッケージに対して新しい Checker インスタンスを返します。 Package ファイルは、checker.Filesを通じて段階的に追加することができます。

func (*Checker) Files 

func (check *Checker) Files(files []*ast.File) (err error)

Filesは、チェッカーのパッケージの一部として提供されたファイルをチェックします。

type Config 

type Config struct {

	// Contextはグローバルな識別子を解決するために使用されるコンテキストです。nilの場合、
	// 型チェッカーはこのフィールドを新たに作成されたコンテキストで初期化します。
	Context *Context

	// GoVersionは、受け入れられるGo言語のバージョンを説明します。文字列は、"go%d.%d"の形式の接頭辞で始まる必要があります（例："go1.20"、"go1.21rc1"、または"go1.21.0"）。または空である必要があります。空の文字列はGo言語のバージョンチェックを無効にします。フォーマットが無効な場合、型チェッカーを呼び出すとエラーが発生します。
	GoVersion string

	// IgnoreFuncBodies が設定されている場合、関数の本体は型チェックされません。
	IgnoreFuncBodies bool

	// If FakeImportC is set, `import "C"` (for packages requiring Cgo)
	// declares an empty "C" package and errors are omitted for qualified
	// identifiers referring to package C (which won't find an object).
	// This feature is intended for the standard library cmd/api tool.
	//
	// Caution: Effects may be unpredictable due to follow-on errors.
	//          Do not use casually!
	FakeImportC bool

	// もしError != nilなら、エラーが見つかるたびに呼び出されます
	// タイプチェック中に見つかったエラーの動的な型はErrorです
	// 二次エラー（例：無効な再帰型宣言に関わるすべての型を列挙する）は'\t'文字で始まるエラー文字列を持ちます
	// もしError == nilなら、最初に見つかったエラーでタイプチェックは停止します。
	Error func(err error)

	// インポート宣言から参照されるパッケージをインポートするためにインポーターが使われます。
	// インストールされたインポーターがImporterFromを実装している場合、型チェッカーはImportFromを呼び出します。
	// インポーターが必要ですがインストールされていない場合、型チェッカーはエラーを報告します。
	Importer Importer

	// Sizesがnilでない場合、unsafeパッケージのサイズ計算関数が提供されます。
	// それ以外の場合はSizesFor("gc", "amd64")が代わりに使用されます。
	Sizes Sizes

	// DisableUnusedImportCheckが設定されている場合、パッケージは未使用のインポートについてチェックされません。
	DisableUnusedImportCheck bool
	// contains filtered or unexported fields
}

Configは型チェックの設定を指定します。 Configのゼロ値は、すぐに使用できるデフォルトの設定です。

func (*Config) Check 

func (conf *Config) Check(path string, fset *token.FileSet, files []*ast.File, info *Info) (*Package, error)

Checkはパッケージの型チェックを行い、結果のパッケージオブジェクトと初めのエラー（もし存在すれば）を返します。さらに、infoがnilでない場合、Checkは Info 構造体の非nilのマップそれぞれを埋めます。 エラーが発生しなかった場合、パッケージは完全であるとマークされます。そうでなければ不完全です。エラーの存在に応じた動作の制御については、[Config.Error] を参照してください。 パッケージはast.Filesのリストと対応するファイルセット、およびパッケージが識別されるパッケージパスで指定されます。クリーンパスは空またはドット（"."）ではないでしょう。

type Const 

type Const struct {
	// contains filtered or unexported fields
}

Constは宣言された定数を表します。

func NewConst 

func NewConst(pos token.Pos, pkg *Package, name string, typ Type, val constant.Value) *Const

NewConstは値valを持つ新しい定数を返します。 残りの引数は、すべてのオブジェクトで見つかる属性を設定します。

func (*Const) String 

func (obj *Const) String() string

func (*Const) Val 

func (obj *Const) Val() constant.Value

Valは定数の値を返します。

type Context added in v1.18.0 

type Context struct {
	// contains filtered or unexported fields
}

Contextは不透明な型チェックコンテキストです。これは、型チェックされたパッケージやInstantiateへの呼び出し間で同じ型のインスタンスを共有するために使用される場合があります。Contextは同時利用に関して安全です。

共有コンテキストの利用は、すべてのケースで同じインスタンスが重複削除されることを保証するものではありません。

func NewContext added in v1.18.0 

func NewContext() *Context

NewContext は新しいコンテキストを作成します。

type Error 

type Error struct {
	Fset *token.FileSet
	Pos  token.Pos
	Msg  string
	Soft bool
	// contains filtered or unexported fields
}

エラーは型チェックのエラーを示します。エラーインターフェースを実装します。 "ソフト"エラーは、パッケージの有効な解釈を許容するエラーです（例：「未使用の変数」）。 "ハード"エラーは無視した場合に予測不可能な動作につながる可能性があります。

func (Error) Error 

func (err Error) Error() string

Errorは以下の形式でフォーマットされたエラー文字列を返します: filename:line:column: message

type Func 

type Func struct {
	// contains filtered or unexported fields
}

Funcは、宣言された関数、具体的なメソッド、または抽象（インターフェース）メソッドを表します。そのType()は常に*Signatureです。 抽象メソッドは、埋め込みにより多くのインターフェースに所属することがあります。

func MissingMethod 

func MissingMethod(V Type, T *Interface, static bool) (method *Func, wrongType bool)

MissingMethodは、VがTを実装している場合、(nil, false)を返します。そうでない場合、Tに必要な欠落しているメソッドと、欠落しているか、または単に間違った型（ポインタレシーバーまたは間違ったシグネチャ）を返します。 非インターフェース型V、またはstaticが設定されている場合、VがTを実装するには、TのすべてのメソッドがVに存在する必要があります。それ以外の場合（Vがインターフェースであり、staticが設定されていない場合）、MissingMethodは、Vにも存在するTのメソッドの型が一致していることだけをチェックします（例：型アサーションx.(T)の場合、xがインターフェース型Vである場合）。

func NewFunc 

func NewFunc(pos token.Pos, pkg *Package, name string, sig *Signature) *Func

NewFuncは与えられたシグネチャを持つ新しい関数を返します。これは関数の型を表します。

func (*Func) FullName 

func (obj *Func) FullName() string

FullNameは関数またはメソッドobjのパッケージ名またはレシーバー型名で修飾された名前を返します。

func (*Func) Origin added in v1.19.0 

func (obj *Func) Origin() *Func

Originは、レシーバーの正確なFunc、つまりInfo.Defsに記録されたFuncオブジェクトを返します。 インスタンス化中に作成された合成関数（具名型のメソッドや型引数に依存するインターフェースのメソッドなど）の場合、これはジェネリック（インスタンス化されていない）型の対応するFuncになります。その他のすべてのFuncに対して、Originはレシーバーを返します。

func (*Func) Pkg added in v1.22.0 

func (obj *Func) Pkg() *Package

Pkg returns the package to which the function belongs.

The result is nil for methods of types in the Universe scope, like method Error of the error built-in interface type.

func (*Func) Scope 

func (obj *Func) Scope() *Scope

Scopeは関数の本体ブロックのスコープを返します。 結果は、インポートされたまたはインスタンス化された関数やメソッドに対してはnilです （ただし、インスタンス化された関数にアクセスするメカニズムもありません）。

func (*Func) Signature added in v1.23.0 

func (obj *Func) Signature() *Signature

Signature returns the signature (type) of the function or method.

func (*Func) String 

func (obj *Func) String() string

type ImportMode added in v1.6.0 

type ImportMode int

ImportMode は将来の利用用途のために予約されています。

type Importer 

type Importer interface {
	Import(path string) (*Package, error)
}

Importerは、インポートパスをパッケージに解決します。

注意: このインターフェースは、ローカルにvendoredされたパッケージのインポートには対応していません。 詳細は、https://golang.org/s/go15vendor を参照してください。 可能であれば、外部の実装では ImporterFrom を実装するべきです。

type ImporterFrom added in v1.6.0 

type ImporterFrom interface {
	Importer

	ImportFrom(path, dir string, mode ImportMode) (*Package, error)
}

ImporterFromは、インポートパスをパッケージに解決します。 https://golang.org/s/go15vendorに従い、ベンダリングをサポートします。 ImporterFromの実装を取得するには、go/importerを使用してください。

type Info 

type Info struct {

	// Typesは式をその型にマップし、定数式の値もマップします。無効な式は省略されます。
	// （カッコで囲まれた）組み込み関数を示す識別子に対して、記録されるシグネチャは呼び出し側に特化されます：
	// 呼び出し結果が定数でない場合、記録される型は引数ごとのシグネチャとなります。それ以外の場合、記録される型は無効です。
	//
	// Typesマップはすべての識別子の型を記録するのではなく、任意の式が許される場所に現れる識別子のみを記録します。
	// たとえば、セレクタ式x.fの中の識別子fはSelectionsマップにのみ存在し、変数宣言 'var z int' の中の識別子zはDefsマップにのみ存在し、
	// 限定識別子内のパッケージを示す識別子はUsesマップに収集されます。
	Types map[ast.Expr]TypeAndValue

	// インスタンス変数は、ジェネリックな型や関数を指定する識別子を、その型引数とインスタンス化された型とのマッピングする。
	//
	// 例えば、T[int, string]という型のインスタンス化において、Tという識別子を[int, string]という型引数とインスタンス化された*Named型とのマッピングを行う。
	// ジェネリックな関数func F[A any](A)が与えられた場合、Fという呼び出し式における識別子を推定された型引数[int]とインスタンス化された*Signatureにマッピングする。
	//
	// 不変条件: Instantiating Uses[id].Type() with Instances[id].TypeArgs は Instances[id].Type と等価な結果を返す。
	Instances map[*ast.Ident]Instance

	// Defsは識別子を定義するオブジェクト（パッケージ名、ドットインポートの"."、ブランクの"_"識別子を含む）にマップします。
	// オブジェクトを示さない識別子（例：パッケージ節のパッケージ名、または型スイッチヘッダーのt := x.(type)における記号変数t）の場合、対応するオブジェクトはnilです。
	//
	// 埋め込まれたフィールドの場合、Defsはフィールド*Varを返します。
	//
	// 不変条件: Defs[id] == nil || Defs[id].Pos() == id.Pos()
	Defs map[*ast.Ident]Object

	// マップは識別子をその指すオブジェクトに使用します。
	//
	// 埋め込みフィールドの場合、Usesは指定された*TypeNameを返します。
	//
	// 不変条件: Uses[id].Pos() != id.Pos()
	Uses map[*ast.Ident]Object

	// インプリシットは、ノードを暗黙的に宣言されたオブジェクトにマッピングします（オブジェクトがある場合）。
	// 次のノードとオブジェクトのタイプが表示される場合があります：
	//
	//     ノード                   宣言されたオブジェクト
	//
	//     *ast.ImportSpec    名前変更のないimportの場合は*PkgName
	//     *ast.CaseClause    typeスイッチの各case節（デフォルトを含む）ごとのtype固有の*Var
	//     *ast.Field         匿名パラメータ *Var（無名の結果を含む）
	Implicits map[ast.Node]Object

	// Selectionsはセレクタ式（修飾子を除く）をその対応する選択肢にマッピングします。
	Selections map[*ast.SelectorExpr]*Selection

	// Scopesは、ast.Nodesをそれらが定義するスコープにマッピングします。パッケージスコープは特定のノードではなく、
	// パッケージに属するすべてのファイルに関連付けられています。
	// したがって、パッケージスコープは型チェックされたPackageオブジェクトで見つけることができます。
	// スコープはネストし、Universeスコープが最も外側のスコープで、パッケージスコープを囲み、
	// それには（1つ以上の）ファイルスコープが含まれ、それらは関数スコープを囲み、
	// その順番でステートメントと関数リテラルスコープを囲みます。
	// パッケージレベルの関数はパッケージスコープで宣言されますが、関数スコープは関数宣言を含むファイルの
	// ファイルスコープに埋め込まれています。
	//
	// 関数のScopeには、型パラメータ、パラメータ、名前付き結果の宣言、および
	// ボディブロックのローカル宣言が含まれます。
	// それは関数の構文（[*ast.FuncDecl]または[*ast.FuncLit]）の完全な範囲と一致します。
	// Scopesマッピングには、関数ボディ（[*ast.BlockStmt]）のエントリは含まれていません。
	// 関数のスコープは[*ast.FuncType]に関連付けられています。
	//
	// 以下のノードタイプが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]*Scope

	// InitOrderはパッケージレベルの初期化子のリストであり、実行する必要がある順序で並んでいます。初期化依存関係に関連する変数を参照する初期化子は、トポロジカル順序で表示されます。他の初期化子はソース順序で表示されます。初期化式を持たない変数は、このリストに表示されません。
	InitOrder []*Initializer

	// FileVersions maps a file to its Go version string.
	// If the file doesn't specify a version, the reported
	// string is Config.GoVersion.
	// Version strings begin with “go”, like “go1.21”, and
	// are suitable for use with the [go/version] package.
	FileVersions map[*ast.File]string
}

Infoは型チェック済みパッケージの結果タイプ情報を保持します。 マップが提供された情報のみ収集されます。 パッケージに型エラーがある場合、収集された情報は不完全である場合があります。

Example

ExampleInfoは、型チェッカーによって型構造体(types.Info)に記録されたさまざまな事実を出力します。名前付きオブジェクトの定義と参照、パッケージ内のすべての式の型、値、モードなどが含まれます。 

// 1つのソースファイルを解析する。
const input = `
package fib

type S string

var a, b, c = len(b), S(c), "hello"

func fib(x int) int {
	if x < 2 {
		return x
	}
	return fib(x-1) - fib(x-2)
}`

// このテストでは、位置情報のために特定のファイルセットが必要です。
// 型チェックのヘルパーは使用できません。
fset := token.NewFileSet()
f := mustParse(fset, input)

// パッケージの型チェックを行います。
// 我々は興味のある各種類の入力に対して空のマップを作成し、Checkがそれらを埋め込みます。
info := types.Info{
	Types: make(map[ast.Expr]types.TypeAndValue),
	Defs:  make(map[*ast.Ident]types.Object),
	Uses:  make(map[*ast.Ident]types.Object),
}
var conf types.Config
pkg, err := conf.Check("fib", fset, []*ast.File{f}, &info)
if err != nil {
	log.Fatal(err)
}

// 初期化順にパッケージレベルの変数を表示する。
fmt.Printf("InitOrder: %v\n\n", info.InitOrder)

// 各名前付きオブジェクトについて、その定義の行と列、およびそれぞれの使用箇所を出力します。
fmt.Println("Defs and Uses of each named object:")
usesByObj := make(map[types.Object][]string)
for id, obj := range info.Uses {
	posn := fset.Position(id.Pos())
	lineCol := fmt.Sprintf("%d:%d", posn.Line, posn.Column)
	usesByObj[obj] = append(usesByObj[obj], lineCol)
}
var items []string
for obj, uses := range usesByObj {
	slices.Sort(uses)
	item := fmt.Sprintf("%s:\n  defined at %s\n  used at %s",
		types.ObjectString(obj, types.RelativeTo(pkg)),
		fset.Position(obj.Pos()),
		strings.Join(uses, ", "))
	items = append(items, item)
}
slices.Sort(items) // 実質的には、行：列によるソート
fmt.Println(strings.Join(items, "\n"))
fmt.Println()

fmt.Println("Types and Values of each expression:")
items = nil
for expr, tv := range info.Types {
	var buf strings.Builder
	posn := fset.Position(expr.Pos())
	tvstr := tv.Type.String()
	if tv.Value != nil {
		tvstr += " = " + tv.Value.String()
	}
	// 行：列 | 式 | モード：型 = 値
	fmt.Fprintf(&buf, "%2d:%2d | %-19s | %-7s : %s",
		posn.Line, posn.Column, exprString(fset, expr),
		mode(tv), tvstr)
	items = append(items, buf.String())
}
slices.Sort(items)
fmt.Println(strings.Join(items, "\n"))

Output:

InitOrder: [c = "hello" b = S(c) a = len(b)]

Defs and Uses of each named object:
builtin len:
  defined at -
  used at 6:15
func fib(x int) int:
  defined at fib:8:6
  used at 12:20, 12:9
type S string:
  defined at fib:4:6
  used at 6:23
type int:
  defined at -
  used at 8:12, 8:17
type string:
  defined at -
  used at 4:8
var b S:
  defined at fib:6:8
  used at 6:19
var c string:
  defined at fib:6:11
  used at 6:25
var x int:
  defined at fib:8:10
  used at 10:10, 12:13, 12:24, 9:5

Types and Values of each expression:
 4: 8 | string              | type    : string
 6:15 | len                 | builtin : func(fib.S) int
 6:15 | len(b)              | value   : int
 6:19 | b                   | var     : fib.S
 6:23 | S                   | type    : fib.S
 6:23 | S(c)                | value   : fib.S
 6:25 | c                   | var     : string
 6:29 | "hello"             | value   : string = "hello"
 8:12 | int                 | type    : int
 8:17 | int                 | type    : int
 9: 5 | x                   | var     : int
 9: 5 | x < 2               | value   : untyped bool
 9: 9 | 2                   | value   : int = 2
10:10 | x                   | var     : int
12: 9 | fib                 | value   : func(x int) int
12: 9 | fib(x - 1)          | value   : int
12: 9 | fib(x-1) - fib(x-2) | value   : int
12:13 | x                   | var     : int
12:13 | x - 1               | value   : int
12:15 | 1                   | value   : int = 1
12:20 | fib                 | value   : func(x int) int
12:20 | fib(x - 2)          | value   : int
12:24 | x                   | var     : int
12:24 | x - 2               | value   : int
12:26 | 2                   | value   : int = 2

func (*Info) ObjectOf 

func (info *Info) ObjectOf(id *ast.Ident) Object

ObjectOfは、指定したidによって指示されたオブジェクトを返します。 存在しない場合はnilを返します。

idが埋め込み構造体フィールドである場合、Info.ObjectOf はフィールド(*Var)を返します それが定義する特定のフィールド(*TypeName)ではありません。

前提条件：UsesおよびDefsマップが入力されています。

func (*Info) PkgNameOf added in v1.22.0 

func (info *Info) PkgNameOf(imp *ast.ImportSpec) *PkgName

PkgNameOfは、インポートによって定義されたローカルパッケージ名を返します。 見つからない場合はnilを返します。

ドットインポートの場合、パッケージ名は"."です。

Precondition: DefsとImplictsのマップが設定されています。

func (*Info) TypeOf 

func (info *Info) TypeOf(e ast.Expr) Type

TypeOfは式eの型を返します。見つからない場合はnilを返します。 前提条件：Types、Uses、Defsのマップが入力されていることが前提です。

type Initializer 

type Initializer struct {
	Lhs []*Var
	Rhs ast.Expr
}

イニシャライザは、パッケージレベルの変数、または複数の値を持つ初期化式の場合、変数のリストと対応する初期化式を表します。

func (*Initializer) String 

func (init *Initializer) String() string

type Instance added in v1.18.0 

type Instance struct {
	TypeArgs *TypeList
	Type     Type
}

Instanceは、型と関数のインスタンス化のための型引数とインスタンス化された型を報告します。型のインスタンス化では、Type は動的型*Named になります。関数のインスタンス化では、Type は動的型*Signatureになります。

type Interface 

type Interface struct {
	// contains filtered or unexported fields
}

インターフェースはインターフェース型を表します。

func NewInterface 

func NewInterface(methods []*Func, embeddeds []*Named) *Interface

NewInterfaceは与えられたメソッドと埋め込まれた型に対して新しいインターフェースを返します。 NewInterfaceは提供されたメソッドの所有権を持ち、欠けているレシーバーを設定することでその型を変更する可能性があります。

廃止予定: 代わりに任意の埋め込まれた型を許可するNewInterfaceTypeを使用してください。

func NewInterfaceType added in v1.11.0 

func NewInterfaceType(methods []*Func, embeddeds []Type) *Interface

NewInterfaceTypeは、指定されたメソッドと埋め込み型に対して新しいインターフェースを返します。 NewInterfaceTypeは、提供されたメソッドの所有権を受け取り、抜けているレシーバを設定することで型を変更する場合があります。

レースコンディションを避けるために、インターフェースの型セットは、インターフェースの並行使用前にCompleteを明示的に呼び出すことで計算する必要があります。

func (*Interface) Complete 

func (t *Interface) Complete() *Interface

Completeはインターフェースのタイプセットを計算します。これは、 NewInterfaceType と NewInterface のユーザーによって呼び出される必要があります。インターフェースの埋め込まれた型が完全に定義され、他の型を形成する以外の方法でインターフェースのタイプを使用する前に呼び出す必要があります。インターフェースに重複するメソッドが含まれている場合、パニックが発生します。Completeはレシーバーを返します。

完了済みのインターフェース型は、同時に使用することが安全です。

func (*Interface) Embedded deprecated 

func (t *Interface) Embedded(i int) *Named

Embeddedは、0 <= i < t.NumEmbeddeds() の範囲でインターフェースtのi番目の埋め込まれた(*Named)型を返します。 i番目の埋め込まれた型が定義済みの型でない場合、結果はnilです。

Deprecated: 定義済みの(*Named)型に制限されない Interface.EmbeddedType を使用してください。

func (*Interface) EmbeddedType added in v1.11.0 

func (t *Interface) EmbeddedType(i int) Type

EmbeddedTypeは0 <= i < t.NumEmbeddeds()におけるインターフェースtのi番目の埋め込まれた型を返します。

func (*Interface) EmbeddedTypes added in v1.23.0 

func (t *Interface) EmbeddedTypes() iter.Seq[Type]

EmbeddedTypes returns a go1.23 iterator over the types embedded within an interface.

Example: for e := range t.EmbeddedTypes() { ... }

func (*Interface) Empty 

func (t *Interface) Empty() bool

Emptyはtが空のインターフェースであるかどうかを報告します。

func (*Interface) ExplicitMethod 

func (t *Interface) ExplicitMethod(i int) *Func

ExplicitMethodは0 <= i < t.NumExplicitMethods()に対して、インターフェースtのi番目に明示的に宣言されたメソッドを返します。 メソッドは一意の Id によって順序付けられます。

func (*Interface) ExplicitMethods added in v1.23.0 

func (t *Interface) ExplicitMethods() iter.Seq[*Func]

ExplicitMethods returns a go1.23 iterator over the explicit methods of an interface, ordered by Id.

Example: for m := range t.ExplicitMethods() { ... }

func (*Interface) IsComparable added in v1.18.0 

func (t *Interface) IsComparable() bool

IsComparableはインターフェースtの型セットの各タイプが比較可能かどうかを報告します。

func (*Interface) IsImplicit added in v1.18.0 

func (t *Interface) IsImplicit() bool

IsImplicitは、インターフェースtが型セットリテラルのラッパーであるかどうかを報告します。

func (*Interface) IsMethodSet added in v1.18.0 

func (t *Interface) IsMethodSet() bool

IsMethodSetは、インタフェースtがそのメソッドセットによって完全に記述されているかどうかを報告します。

func (*Interface) MarkImplicit added in v1.18.0 

func (t *Interface) MarkImplicit()

MarkImplicitは、interface tを暗黙的にマークします。 これは、明示的なinterfaceの埋め込みなしに、~TやA|Bなどの制約リテラルに対応することを意味します。 MarkImplicitは、暗黙のinterfaceを同時使用する前に呼び出す必要があります。

func (*Interface) Method 

func (t *Interface) Method(i int) *Func

メソッドは、0 <= i < t.NumMethods() を満たす i の場合に、 インターフェース t の i 番目のメソッドを返します。 メソッドはそのユニークな ID によって順序づけされます。

func (*Interface) Methods added in v1.23.0 

func (t *Interface) Methods() iter.Seq[*Func]

Methods returns a go1.23 iterator over all the methods of an interface, ordered by Id.

Example: for m := range t.Methods() { ... }

func (*Interface) NumEmbeddeds 

func (t *Interface) NumEmbeddeds() int

NumEmbeddeds はインターフェース t 内の埋め込まれた型の数を返します。

func (*Interface) NumExplicitMethods 

func (t *Interface) NumExplicitMethods() int

NumExplicitMethods はインターフェース t の明示的に宣言されたメソッドの数を返します。

func (*Interface) NumMethods 

func (t *Interface) NumMethods() int

NumMethodsはインターフェースtのメソッドの合計数を返します。

func (*Interface) String 

func (t *Interface) String() string

func (*Interface) Underlying 

func (t *Interface) Underlying() Type

type Label 

type Label struct {
	// contains filtered or unexported fields
}

Labelは宣言されたラベルを表します。 ラベルはタイプを持ちません。

func NewLabel 

func NewLabel(pos token.Pos, pkg *Package, name string) *Label

NewLabel は新しいラベルを返します。

func (*Label) String 

func (obj *Label) String() string

type Map 

type Map struct {
	// contains filtered or unexported fields
}

Mapはマップ型を表します。

func NewMap 

func NewMap(key, elem Type) *Map

NewMapは与えられたキーと要素の型のための新しいマップを返します。

func (*Map) Elem 

func (m *Map) Elem() Type

Elemは、マップmの要素の型を返します。

func (*Map) Key 

func (m *Map) Key() Type

Keyはマップmのキーの型を返します。

func (*Map) String 

func (t *Map) String() string

func (*Map) Underlying 

func (t *Map) Underlying() Type

type MethodSet 

type MethodSet struct {
	// contains filtered or unexported fields
}

MethodSetは具体的または抽象（インターフェース）メソッドの順序付けられたセットです。 メソッドは MethodVal 選択であり、m.Obj().Id()によって昇順に並べられます。 MethodSetのゼロ値は使用準備完了の空のメソッドセットです。

Example

ExampleMethodSet は様々な型のメソッドセットを表示します。 

package main

import (
	"github.com/shogo82148/std/fmt"
	"github.com/shogo82148/std/go/ast"
	"github.com/shogo82148/std/go/importer"
	"github.com/shogo82148/std/go/parser"
	"github.com/shogo82148/std/go/token"
	"github.com/shogo82148/std/go/types"
	"github.com/shogo82148/std/log"
)

func main() {
	// 1つのソースファイルを解析する。
	const input = `
package temperature
import "fmt"
type Celsius float64
func (c Celsius) String() string  { return fmt.Sprintf("%g°C", c) }
func (c *Celsius) SetF(f float64) { *c = Celsius(f - 32 / 9 * 5) }

type S struct { I; m int }
type I interface { m() byte }
`
	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, "celsius.go", input, 0)
	if err != nil {
		log.Fatal(err)
	}

	// このファイルからなるパッケージを型チェックします。
	// インポートされたパッケージの型情報は、$GOROOT/pkg/$GOOS_$GOOARCH/fmt.a から来ます。
	conf := types.Config{Importer: importer.Default()}
	pkg, err := conf.Check("temperature", fset, []*ast.File{f}, nil)
	if err != nil {
		log.Fatal(err)
	}

	// Celsiusと*Celsiusのメソッドセットを表示する。
	celsius := pkg.Scope().Lookup("Celsius").Type()
	for _, t := range []types.Type{celsius, types.NewPointer(celsius)} {
		fmt.Printf("Method set of %s:\n", t)
		for m := range types.NewMethodSet(t).Methods() {
			fmt.Println(m)
		}
		fmt.Println()
	}

	// Sのメソッドセットを出力する。
	styp := pkg.Scope().Lookup("S").Type()
	fmt.Printf("Method set of %s:\n", styp)
	fmt.Println(types.NewMethodSet(styp))

}

Output:

Method set of temperature.Celsius:
method (temperature.Celsius) String() string

Method set of *temperature.Celsius:
method (*temperature.Celsius) SetF(f float64)
method (*temperature.Celsius) String() string

Method set of temperature.S:
MethodSet {}

func NewMethodSet 

func NewMethodSet(T Type) *MethodSet

NewMethodSetは、指定された型Tのメソッドセットを返します。 空であっても、必ず非nilのメソッドセットを返します。

func (*MethodSet) At 

func (s *MethodSet) At(i int) *Selection

Atは、0 <= i < s.Len()に対してsのi番目のメソッドを返します。

func (*MethodSet) Len 

func (s *MethodSet) Len() int

Lenはsのメソッドの数を返します。

func (*MethodSet) Lookup 

func (s *MethodSet) Lookup(pkg *Package, name string) *Selection

Lookupはパッケージと名前が一致するメソッドを返します。見つからない場合はnilを返します。

func (*MethodSet) Methods added in v1.23.0 

func (s *MethodSet) Methods() iter.Seq[*Selection]

Methods returns a go1.23 iterator over the methods of a method set.

Example: for method := range s.Methods() { ... }

func (*MethodSet) String 

func (s *MethodSet) String() string

type Named 

type Named struct {
	// contains filtered or unexported fields
}

Namedは名前付き（定義された）型を表します。

func NewNamed 

func NewNamed(obj *TypeName, underlying Type, methods []*Func) *Named

NewNamedは、与えられた型名、基礎型、および関連するメソッドに対して新しい名前付き型を返します。 もし与えられた型名のオブジェクトがまだ型を持っていない場合、その型は返された名前付き型に設定されます。 基礎型は*Namedではない必要があります。

func (*Named) AddMethod 

func (t *Named) AddMethod(m *Func)

AddMethodは、メソッドmがすでにメソッドリストに存在しない場合に追加します。 メソッドはtと同じパッケージに存在しなければならず、tは 型引数を持っていてはなりません。

func (*Named) Method 

func (t *Named) Method(i int) *Func

Method returns the i'th method of named type t for 0 <= i < t.NumMethods().

For an ordinary or instantiated type t, the receiver base type of this method is the named type t. For an uninstantiated generic type t, each method receiver is instantiated with its receiver type parameters.

Methods are numbered deterministically: given the same list of source files presented to the type checker, or the same sequence of NewMethod and AddMethod calls, the mapping from method index to corresponding method remains the same. But the specific ordering is not specified and must not be relied on as it may change in the future.

func (*Named) Methods added in v1.23.0 

func (t *Named) Methods() iter.Seq[*Func]

Methods returns a go1.23 iterator over the declared methods of a named type.

Example: for m := range t.Methods() { ... }

func (*Named) NumMethods 

func (t *Named) NumMethods() int

NumMethodsはtに定義された明示的なメソッドの数を返します。

func (*Named) Obj 

func (t *Named) Obj() *TypeName

Objは、名前tで定義された宣言の型名を返します。インスタンス化された型の場合、これは元の型の型名と同じです。

func (*Named) Origin added in v1.18.0 

func (t *Named) Origin() *Named

Originは、指定された型tがインスタンス化されたジェネリック型を返します。 tがインスタンス化されていない型の場合は、結果はtとなります。

func (*Named) SetTypeParams added in v1.18.0 

func (t *Named) SetTypeParams(tparams []*TypeParam)

SetTypeParamsは名前付き型tの型パラメータを設定します。 tには型引数を持っていてはいけません。

func (*Named) SetUnderlying 

func (t *Named) SetUnderlying(underlying Type)

SetUnderlyingは基本型を設定し、tを完全なものとしてマークします。 tには型引数を持っていてはいけません。

func (*Named) String 

func (t *Named) String() string

func (*Named) TypeArgs added in v1.18.0 

func (t *Named) TypeArgs() *TypeList

TypeArgsは、名前付きの型tをインスタンス化するために使用される型引数を返します。

func (*Named) TypeParams added in v1.18.0 

func (t *Named) TypeParams() *TypeParamList

TypeParams は、名前付きの型 t の型パラメーターを返します。返り値は nil です。 (元々) ジェネリック型である場合、インスタンス化されているかどうかに関わらず、結果は非 nil です。

func (*Named) Underlying 

func (t *Named) Underlying() Type

Underlying returns the underlying type of the named type t, resolving all forwarding declarations. Underlying types are never Named, TypeParam, or Alias types.

type Nil 

type Nil struct {
	// contains filtered or unexported fields
}

Nilは、事前宣言された値であるnilを表します。

func (*Nil) String 

func (obj *Nil) String() string

type Object 

type Object interface {
	Parent() *Scope
	Pos() token.Pos
	Pkg() *Package
	Name() string
	Type() Type
	Exported() bool
	Id() string

	String() string
	// contains filtered or unexported methods
}

Objectは、パッケージ、定数、型、変数、関数（メソッドを含む）、またはラベルなどの名前付きの言語エンティティを表します。 すべてのオブジェクトはObjectインターフェースを実装しています。

func LookupFieldOrMethod 

func LookupFieldOrMethod(T Type, addressable bool, pkg *Package, name string) (obj Object, index []int, indirect bool)

LookupFieldOrMethodは、与えられたパッケージと名前でTというフィールドまたはメソッドを検索し、対応する*Varまたは*Func、インデックスのシーケンス、そしてパスにおいてポインタ間接参照があったかどうかを示すブール値を返します。addressableが設定されている場合、Tはアドレス可能な変数の型です（メソッドの検索にのみ関係します）。Tはnilであってはなりません。 最後のインデックスエントリは、エントリが見つかった（埋め込まれた可能性のある）型のフィールドまたはメソッドのインデックスであり、次のいずれかです：

  1. 名前付き型の宣言されたメソッドのリスト
  2. インターフェース型のすべてのメソッド（メソッドセット）のリスト
  3. 構造体型のフィールドのリスト

より早いインデックスエントリは、見つかったエントリに到達するためにトラバースされた埋め込まれた構造体フィールドのインデックスであり、depth 0から開始します。 エントリが見つからない場合、nilオブジェクトが返されます。この場合、返されるインデックスとindirectの値の意味は次のとおりです：

  • もしindex != nilなら、インデックスシーケンスは曖昧なエントリを指します（同じ名前が同じ埋め込みレベルで複数回現れました）。
  • indirectが設定されている場合、ポインタレシーバータイプを持つメソッドが見つかりましたが、実際のレシーバータイプからメソッドの形式的なレシーバーベースタイプへのパスにポインタがなく、レシーバーがアドレス可能ではありませんでした。

type Package 

type Package struct {
	// contains filtered or unexported fields
}

パッケージはGoのパッケージを説明します。 

var Unsafe *Package

Unsafeパッケージは、importパス"unsafe"のインポータによって返されるパッケージです。

func NewPackage 

func NewPackage(path, name string) *Package

NewPackageは、指定されたパッケージのパスと名前に対して新しいPackageを返します。 このパッケージは完全ではなく、明示的なインポートは含まれていません。

func (*Package) Complete 

func (pkg *Package) Complete() bool

パッケージは、そのスコープに（少なくとも）すべての公開オブジェクトが含まれている場合は完全であり、それ以外の場合は不完全です。

func (*Package) GoVersion added in v1.21.0 

func (pkg *Package) GoVersion() string

GoVersionはこのパッケージで必要な最小のGoバージョンを返します。 もし最小バージョンが分からない場合、GoVersionは空文字列を返します。 各ソースファイルは、[go/ast.File.GoVersion]フィールドに報告されるよう、異なる最小Goバージョンを指定することができます。

func (*Package) Imports 

func (pkg *Package) Imports() []*Package

Importsは、pkgによって直接インポートされたパッケージのリストを返します。リストはソース順に並んでいます。 pkgがエクスポートデータからロードされた場合、Importsにはpkgが参照しているパッケージレベルのオブジェクトを提供するパッケージが含まれます。これは、pkgのソースコードに直接インポートされたパッケージのセットよりも多くまたは少ない場合があります。 pkgがcgoを使用し、FakeImportC構成オプションが有効になっている場合、インポートリストには偽の「C」パッケージが含まれている可能性があります。

func (*Package) MarkComplete 

func (pkg *Package) MarkComplete()

MarkCompleteはパッケージを完了としてマークします。

func (*Package) Name 

func (pkg *Package) Name() string

Nameはパッケージ名を返します。

func (*Package) Path 

func (pkg *Package) Path() string

Pathはパッケージのパスを返します。

func (*Package) Scope 

func (pkg *Package) Scope() *Scope

Scopeは、パッケージレベルで宣言されたオブジェクト（TypeNames、Consts、Vars、およびFuncs）を保持する（完全または不完全な）パッケージスコープを返します。 nilのpkgレシーバーの場合、ScopeはUniverseスコープを返します。

func (*Package) SetImports 

func (pkg *Package) SetImports(list []*Package)

SetImportsは、明示的にインポートされるパッケージのリストを設定します。 リストの要素が一意であることは、呼び出し元の責任です。

func (*Package) SetName added in v1.6.0 

func (pkg *Package) SetName(name string)

SetNameはパッケージ名を設定します。

func (*Package) String 

func (pkg *Package) String() string

type PkgName 

type PkgName struct {
	// contains filtered or unexported fields
}

PkgNameはインポートされたGoパッケージを表します。 PkgNameには型はありません。

func NewPkgName 

func NewPkgName(pos token.Pos, pkg *Package, name string, imported *Package) *PkgName

NewPkgNameは、インポートされたパッケージを表す新しいPkgNameオブジェクトを返します。 残りの引数は、全てのオブジェクトで見つかった属性を設定します。

func (*PkgName) Imported 

func (obj *PkgName) Imported() *Package

Importedはインポートされたパッケージを返します。 これはインポート文を含むパッケージとは異なります。

func (*PkgName) String 

func (obj *PkgName) String() string

type Pointer 

type Pointer struct {
	// contains filtered or unexported fields
}

ポインタはポインタ型を表します。

func NewPointer 

func NewPointer(elem Type) *Pointer

NewPointerは、指定された要素（ベース）タイプの新しいポインタータイプを返します。

func (*Pointer) Elem 

func (p *Pointer) Elem() Type

Elemは与えられたポインタpの要素の型を返します。

func (*Pointer) String 

func (p *Pointer) String() string

func (*Pointer) Underlying 

func (p *Pointer) Underlying() Type

type Qualifier 

type Qualifier func(*Package) string

Qualifierは、TypeString、ObjectString、および SelectionString の呼び出しで名前付きのパッケージレベルのオブジェクトが出力される方法を制御します。

これらの3つのフォーマットルーチンは、Qualifierを各パッケージレベルのオブジェクトOに対して呼び出し、Qualifierが空ではない文字列pを返すと、オブジェクトはp.Oの形式で表示されます。 フォーマットルーチンが空文字列を返す場合、オブジェクト名Oのみが表示されます。

nilのQualifierを使用することは、(*Package).Pathを使用することと同じです：オブジェクトはインポートパスで修飾されます。例えば、"encoding/json.Marshal"となります。

func RelativeTo 

func RelativeTo(pkg *Package) Qualifier

RelativeToは、pkg以外のすべてのパッケージのメンバーを完全に修飾する Qualifier を返します。

type Scope 

type Scope struct {
	// contains filtered or unexported fields
}

スコープはオブジェクトのセットを保持し、それが含まれる（親）スコープと含まれる（子）スコープへのリンクを維持します。オブジェクトは名前で挿入および検索することができます。Scopeのゼロ値は使用可能な空のスコープです。

Example

ExampleScope は解析されたファイルの集まりから作成されたパッケージのスコープのツリーを出力します。 

// パッケージのソースファイルを解析する。
fset := token.NewFileSet()
var files []*ast.File
for _, src := range []string{
	`package main
import "fmt"
func main() {
	freezing := FToC(-18)
	fmt.Println(freezing, Boiling) }
`,
	`package main
import "fmt"
type Celsius float64
func (c Celsius) String() string { return fmt.Sprintf("%g°C", c) }
func FToC(f float64) Celsius { return Celsius(f - 32 / 9 * 5) }
const Boiling Celsius = 100
func Unused() { {}; {{ var x int; _ = x }} } // make sure empty block scopes get printed
`,
} {
	files = append(files, mustParse(fset, src))
}

// これらのファイルから成るパッケージの型チェックを行います。
// インポートされた "fmt" パッケージの型情報は、$GOROOT/pkg/$GOOS_$GOOARCH/fmt.a から取得されます。
conf := types.Config{Importer: importer.Default()}
pkg, err := conf.Check("temperature", fset, files, nil)
if err != nil {
	log.Fatal(err)
}

// スコープツリーを表示します。
// 同一性を確保するために、アドレスは非表示にします。
var buf strings.Builder
pkg.Scope().WriteTo(&buf, 0, true)
rx := regexp.MustCompile(` 0x[a-fA-F\d]*`)
fmt.Println(rx.ReplaceAllString(buf.String(), ""))

Output:

package "temperature" scope {
.  const temperature.Boiling temperature.Celsius
.  type temperature.Celsius float64
.  func temperature.FToC(f float64) temperature.Celsius
.  func temperature.Unused()
.  func temperature.main()
.  main scope {
.  .  package fmt
.  .  function scope {
.  .  .  var freezing temperature.Celsius
.  .  }
.  }
.  main scope {
.  .  package fmt
.  .  function scope {
.  .  .  var c temperature.Celsius
.  .  }
.  .  function scope {
.  .  .  var f float64
.  .  }
.  .  function scope {
.  .  .  block scope {
.  .  .  }
.  .  .  block scope {
.  .  .  .  block scope {
.  .  .  .  .  var x int
.  .  .  .  }
.  .  .  }
.  .  }
.  }
}

var Universe *Scope

UniverseスコープにはGoのすべての事前宣言されたオブジェクトが含まれています。 これはネストされたスコープチェーンの最外側のスコープです。

func NewScope 

func NewScope(parent *Scope, pos, end token.Pos, comment string) *Scope

NewScopeは、指定された親スコープに含まれる新しい空のスコープを返します（存在する場合）。コメントはデバッグ用です。

func (*Scope) Child 

func (s *Scope) Child(i int) *Scope

Childは0 <= i < NumChildren()の範囲でi番目の子スコープを返します。

func (*Scope) Children added in v1.23.0 

func (s *Scope) Children() iter.Seq[*Scope]

Children returns a go1.23 iterator over the child scopes nested within scope s.

Example: for child := range scope.Children() { ... }

func (*Scope) Contains 

func (s *Scope) Contains(pos token.Pos) bool

Containsは、posがスコープの範囲内にあるかどうかを報告します。 結果は、型チェック済みのASTに完全な位置情報がある場合にのみ有効です。

func (*Scope) End 

func (s *Scope) End() token.Pos

func (*Scope) Innermost 

func (s *Scope) Innermost(pos token.Pos) *Scope

Innermostは、posを含む最も内側（子）のスコープを返します。 posがどのスコープにも含まれていない場合、結果はnilになります。 Universeスコープの場合も結果はnilです。 結果は、型チェック済みのASTに完全な位置情報がある場合にのみ有効です。

func (*Scope) Insert 

func (s *Scope) Insert(obj Object) Object

Insertはオブジェクトobjをスコープsに挿入します。 もしsが同じ名前の代替オブジェクトaltを既に含んでいる場合、Insertはsを変更せずにaltを返します。 そうでなければ、objを挿入し、オブジェクトの親スコープを設定し、nilを返します。

func (*Scope) Len 

func (s *Scope) Len() int

Lenはスコープ要素の数を返します。

func (*Scope) Lookup 

func (s *Scope) Lookup(name string) Object

Lookupは、名前が与えられたスコープs内のオブジェクトを返します。 オブジェクトが存在する場合はそのオブジェクトを返し、存在しない場合はnilを返します。

func (*Scope) LookupParent 

func (s *Scope) LookupParent(name string, pos token.Pos) (*Scope, Object)

LookupParentは、sから始まるスコープの親チェーンをたどり、Lookup（name）が非nilのオブジェクトを返すスコープを見つけ、そのスコープとオブジェクトを返します。有効な位置posが指定された場合、posで宣言されたかそれ以前のオブジェクトのみが考慮されます。このようなスコープとオブジェクトが存在しない場合、結果は（nil、nil）です。 obj.Parent()は、オブジェクトがスコープに挿入され、すでにその時点で親があった場合に、返されたスコープと異なるかもしれないことに注意してください（Insertを参照）。これは、スコープがそれらをエクスポートしたパッケージのスコープであるドットインポートされたオブジェクトにのみ起こり得ます。

func (*Scope) Names 

func (s *Scope) Names() []string

Namesはスコープ内の要素名をソートされた順序で返します。

func (*Scope) NumChildren 

func (s *Scope) NumChildren() int

NumChildrenはsにネストされたスコープの数を返します。

func (*Scope) Parent 

func (s *Scope) Parent() *Scope

Parentはスコープの含まれる（親）スコープを返します。

func (*Scope) Pos 

func (s *Scope) Pos() token.Pos

PosとEndは、スコープのソースコード範囲[pos, end)を記述します。 結果は、型チェックされたASTが完全な位置情報を持っている場合にのみ有効であることが保証されます。 範囲は、Universeとパッケージスコープでは未定義です。

func (*Scope) String 

func (s *Scope) String() string

Stringはデバッグ用のスコープの文字列表現を返します。

func (*Scope) WriteTo 

func (s *Scope) WriteTo(w io.Writer, n int, recurse bool)

WriteToは、スコープの文字列表現をwに書き込みます。 スコープ要素は名前でソートされます。 インデントのレベルはn >= 0で制御され、 インデントなしの場合はn == 0です。 recurseが設定されている場合は、ネストされた（子）スコープも書き込みます。

type Selection 

type Selection struct {
	// contains filtered or unexported fields
}

Selection（セレクション）は、セレクタ式 x.f を表します。 次の宣言に対して： 

type T struct{ x int; E }
type E struct{}
func (e E) m() {}
var p *T

以下の関係が存在します： 

Selector    Kind          Recv    Obj    Type       Index     Indirect

p.x         FieldVal      T       x      int        {0}       true
p.m         MethodVal     *T      m      func()     {1, 0}    true
T.m         MethodExpr    T       m      func(T)    {1, 0}    false

func (*Selection) Index 

func (s *Selection) Index() []int

Index はxからfへのパスを記述します。 最後のindexエントリは、fを宣言している型のフィールドまたはメソッドのindexです。 以下のいずれかです:

  1. 名前付き型の宣言されたメソッドのリスト
  2. インターフェース型のメソッドのリスト
  3. 構造体型のフィールドのリスト

より早いindexエントリは、埋め込まれたフィールドのindexであり、 xからfに移動するために（xの型から）暗黙的にトラバースされる埋め込みの深さ0から始まります。

func (*Selection) Indirect 

func (s *Selection) Indirect() bool

Indirectは、x.fでxからfへ移動するためにポインタ間接参照が必要だったかどうかを報告します。

注意：レシーバ引数とパラメータの両方が型*Tを持つMethodVal選択で、 間接参照がないにもかかわらず、Indirectが誤ってtrueを返す（Go issue #8353）ことがあります。 残念ながら、修正はリスクが高すぎます。

func (*Selection) Kind 

func (s *Selection) Kind() SelectionKind

Kindは選択の種類を返します。

func (*Selection) Obj 

func (s *Selection) Obj() Object

Obj は x.f によって指定されたオブジェクトを返します。フィールドの選択には *Var を、それ以外の場合は *Func を返します。

func (*Selection) Recv 

func (s *Selection) Recv() Type

Recvはx.fの型を返します。

func (*Selection) String 

func (s *Selection) String() string

func (*Selection) Type 

func (s *Selection) Type() Type

Typeはx.fの型を返しますが、fの型とは異なる場合があります。 詳細はSelectionを参照してください。

type SelectionKind 

type SelectionKind int

SelectionKindは、セレクタ式x.fの種類を記述します （修飾識別子は除く）。

xがstructまたは*structの場合、セレクタ式x.fは 一連の選択操作x.a.b.c.fを表す可能性があります。SelectionKindは 最終的な（明示的な）操作の種類を記述します。すべての 以前の（暗黙的な）操作は常にフィールド選択です。 Indicesの各要素は、暗黙的なフィールド（a、b、c）を フィールド選択オペランドのstruct型のインデックスで指定します。

FieldVal操作の場合、最終的な選択はSelection.Objで指定されたフィールドを参照します。

MethodVal操作の場合、最終的な選択はメソッドを参照します。 メソッドの宣言されたレシーバの"ポインタ性"が、暗黙のフィールド 選択後の実効レシーバと一致しない場合、&または*操作が暗黙的に レシーバ変数または値に適用されます。 したがって、fがポインタレシーバを必要とするがx.a.b.cが非ポインタ変数である場合、 x.fは(&x.a.b.c).fを表します。また、fが非ポインタレシーバを必要とするが x.a.b.cがポインタ値である場合、x.fは(*x.a.b.c).fを表します。

暗黙的または明示的なフィールド選択、または"ポインタ性"のために挿入された*操作による すべてのポインタ間接参照は、nilポインタに適用されるとパニックを引き起こします。 したがって、メソッド呼び出しx.f()は、関数呼び出しの前にパニックを引き起こす可能性があります。

対照的に、MethodExpr操作T.fは基本的に以下の形式の関数リテラルと等価です： 

func(x T, args) (results) { return x.f(args) }

その結果、"ポインタ性"のために挿入された任意の暗黙的なフィールド選択と*操作は、 関数が呼び出されるまで評価されません。したがって、T.fまたは(*T).fの式は決してパニックしません。 

const (
	FieldVal SelectionKind = iota
	MethodVal
	MethodExpr
)

type Signature 

type Signature struct {
	// contains filtered or unexported fields
}

Signatureは（ビルトインでない）関数またはメソッドの型を表します。 シグネチャを同一性で比較する際は、レシーバは無視されます。

func NewSignature deprecated 

func NewSignature(recv *Var, params, results *Tuple, variadic bool) *Signature

NewSignatureは与えられたレシーバ、パラメータ、戻り値のための新しい関数型を返します。それぞれnilにすることもできます。もしvariadicがtrueに設定されている場合、関数は可変長引数を持ち、少なくとも1つのパラメータを持つ必要があります。また、最後のパラメータは無名のスライス型である必要があります。

Deprecated: 代わりに型パラメータを使用できる NewSignatureType を使用してください。

func NewSignatureType added in v1.18.0 

func NewSignatureType(recv *Var, recvTypeParams, typeParams []*TypeParam, params, results *Tuple, variadic bool) *Signature

NewSignatureTypeは、与えられたレシーバ、レシーバタイプパラメータ、 タイプパラメータ、パラメータ、および結果に対して新しい関数型を作成します。 variadicが設定されている場合、paramsは少なくとも1つのパラメータを保持している必要があり、 最後のパラメータのコア型は未命名スライスまたはバイト文字列型である必要があります。 recvがnilでない場合、typeParamsは空でなければなりません。 recvTypeParamsが空でない場合、recvはnilではない必要があります。

func (*Signature) Params 

func (s *Signature) Params() *Tuple

Paramsはシグネチャsのパラメータを返します。パラメータがない場合はnilを返します。

func (*Signature) Recv 

func (s *Signature) Recv() *Var

Recv returns the receiver of signature s (if a method), or nil if a function. It is ignored when comparing signatures for identity.

For an abstract method, Recv returns the enclosing interface either as a *Named or an *Interface. Due to embedding, an interface may contain methods whose receiver type is a different interface.

func (*Signature) RecvTypeParams added in v1.18.0 

func (s *Signature) RecvTypeParams() *TypeParamList

RecvTypeParams はシグネチャ s のレシーバー型パラメーターを返します。nil の場合もあります。

func (*Signature) Results 

func (s *Signature) Results() *Tuple

Resultsはシグネチャsの結果、またはnilを返します。

func (*Signature) String 

func (s *Signature) String() string

func (*Signature) TypeParams added in v1.18.0 

func (s *Signature) TypeParams() *TypeParamList

TypeParamsはシグネチャsの型パラメータを返します。パラメータが存在しない場合はnilを返します。

func (*Signature) Underlying 

func (s *Signature) Underlying() Type

func (*Signature) Variadic 

func (s *Signature) Variadic() bool

Variadicは、シグネチャsが可変長引数であるかどうかを報告します。

type Sizes 

type Sizes interface {
	Alignof(T Type) int64

	Offsetsof(fields []*Var) []int64

	Sizeof(T Type) int64
}

Sizesはパッケージunsafeのサイズ決定関数を定義します。

func SizesFor added in v1.9.0 

func SizesFor(compiler, arch string) Sizes

SizesForは、コンパイラがアーキテクチャで使用するサイズを返します。 コンパイラ/アーキテクチャの組み合わせが不明な場合、結果はnilです。

コンパイラ"gc"に対応したアーキテクチャ: "386", "amd64", "amd64p32", "arm", "arm64", "loong64", "mips", "mipsle", "mips64", "mips64le", "ppc64", "ppc64le", "riscv64", "s390x", "sparc64", "wasm"。

type Slice 

type Slice struct {
	// contains filtered or unexported fields
}

Sliceはスライス型を表します。

func NewSlice 

func NewSlice(elem Type) *Slice

NewSliceは与えられた要素タイプ用の新しいスライスタイプを返します。

func (*Slice) Elem 

func (s *Slice) Elem() Type

Elemはスライスsの要素の型を返します。

func (*Slice) String 

func (s *Slice) String() string

func (*Slice) Underlying 

func (s *Slice) Underlying() Type

type StdSizes 

type StdSizes struct {
	WordSize int64
	MaxAlign int64
}

StdSizesはよく使われるサイズを作成するための便利な型です。 以下の単純化された仮定を行います：

  • 明示的なサイズの基本型（int16など）のサイズは指定されたサイズです。
  • 文字列とインターフェースのサイズは2 * WordSizeです。
  • スライスのサイズは3 * WordSizeです。
  • n要素の配列のサイズは、配列要素の型のn連続フィールドの配列のサイズに対応します。
  • 構造体のサイズは、最後のフィールドのオフセットにそのフィールドのサイズを加えたものです。 すべての要素型と同様に、構造体が配列で使用される場合、そのサイズはまず構造体のアライメントの倍数に揃える必要があります。
  • その他のすべての型のサイズはWordSizeです。
  • 配列と構造体は仕様の定義に従ってアラインされます。その他のすべての型は最大アラインメントMaxAlignで自然にアラインされます。

*StdSizesはSizesを実装しています。

func (*StdSizes) Alignof 

func (s *StdSizes) Alignof(T Type) (result int64)

func (*StdSizes) Offsetsof 

func (s *StdSizes) Offsetsof(fields []*Var) []int64

func (*StdSizes) Sizeof 

func (s *StdSizes) Sizeof(T Type) int64

type Struct 

type Struct struct {
	// contains filtered or unexported fields
}

Structはstruct型を表します。

func NewStruct 

func NewStruct(fields []*Var, tags []string) *Struct

NewStructは、指定されたフィールドと対応するフィールドタグを持つ新しい構造体を返します。 インデックスiを持つフィールドにタグがある場合、tags [i]はそのタグである必要がありますが、 tagsの長さは、最大インデックスiのタグを保持するために必要なだけの長さである場合があります。 したがって、フィールドにタグがない場合、tagsはnilである場合があります。

func (*Struct) Field 

func (s *Struct) Field(i int) *Var

Fieldは0 <= i < NumFields()という条件でi番目のフィールドを返します。

func (*Struct) Fields added in v1.23.0 

func (s *Struct) Fields() iter.Seq[*Var]

Fields returns a go1.23 iterator over the fields of a struct type.

Example: for field := range s.Fields() { ... }

func (*Struct) NumFields 

func (s *Struct) NumFields() int

NumFieldsは、struct内のフィールドの数を返します（空白や埋め込まれたフィールドを含む）。

func (*Struct) String 

func (t *Struct) String() string

func (*Struct) Tag 

func (s *Struct) Tag(i int) string

Tagは0 <= i < NumFields()に対するi番目のフィールドタグを返します。

func (*Struct) Underlying 

func (t *Struct) Underlying() Type

type Term added in v1.18.0 

type Term term

Termは Union 内の項を表します。

func NewTerm added in v1.18.0 

func NewTerm(tilde bool, typ Type) *Term

NewTermは新しいユニオン用語を返します。

func (*Term) String added in v1.18.0 

func (t *Term) String() string

func (*Term) Tilde added in v1.18.0 

func (t *Term) Tilde() bool

func (*Term) Type added in v1.18.0 

func (t *Term) Type() Type

type Tuple 

type Tuple struct {
	// contains filtered or unexported fields
}

Tupleは変数の順序付きリストを表します。nil *Tupleは有効な（空の）タプルです。 Tupleはシグネチャの構成要素や複数の代入の型を表すために使用されますが、Goのファーストクラスの型ではありません。

func NewTuple 

func NewTuple(x ...*Var) *Tuple

NewTupleは指定された変数に対して新しいタプルを返します。

func (*Tuple) At 

func (t *Tuple) At(i int) *Var

Atはタプルtのi番目の変数を返します。

func (*Tuple) Len 

func (t *Tuple) Len() int

Lenはタプルtの変数の数を返します。

func (*Tuple) String 

func (t *Tuple) String() string

func (*Tuple) Underlying 

func (t *Tuple) Underlying() Type

func (*Tuple) Variables added in v1.23.0 

func (t *Tuple) Variables() iter.Seq[*Var]

Variables returns a go1.23 iterator over the variables of a tuple type.

Example: for v := range tuple.Variables() { ... }

type Type 

type Type interface {
	Underlying() Type

	String() string
}

TypeはGoの型を表します。 すべての型はTypeインターフェースを実装しています。

func Default added in v1.8.0 

func Default(t Type) Type

Defaultは、「未指定の」型に対して「型付き」のデフォルト型を返します； 他のすべての型に対しては、入力された型を返します。未指定のnilのデフォルト型は未指定のnilです。

func Instantiate added in v1.18.0 

func Instantiate(ctxt *Context, orig Type, targs []Type, validate bool) (Type, error)

Instantiateは、与えられた型引数targsで型origをインスタンス化します。 origは*Alias、*Named、または*Signature型でなければなりません。エラーがない場合、 結果のTypeは同じ種類（それぞれ*Alias、*Named、または*Signature）のインスタンス化された型です。

*Named型にアタッチされたメソッドもインスタンス化され、元のメソッドと同じ位置を持つが関数スコープがnilの新しい*Funcに関連付けられます。

ctxtがnilでない場合、同じ識別子を持つ以前のインスタンスと重複排除するために使用できます。 特別な場合として、ジェネリックの*Signatureの元の型は、ポインタの等価性がある場合のみ同一視されるため、 異なる（しかし可能性としては同一の）シグネチャをインスタンス化すると、異なるインスタンスが生成されます。 共有されたコンテキストの使用は、同じインスタンスがすべての場合で重複排除されることを保証しません。

validateが設定されている場合、Instantiateは型引数とパラメータの数が一致していること、および型引数がそれぞれの型制約を満たしていることを検証します。 検証に失敗した場合、結果のエラーは*ArgumentErrorをラップする可能性があり、どの型引数がその型パラメータの制約を満たさなかったか、およびなぜ満たさなかったかを示します。

validateが設定されていない場合、Instantiateは型引数の数や型引数が制約を満たしているかどうかを検証しません。 Instantiateはエラーを返さないことが保証されていますが、パニックする可能性があります。 具体的には、*Signature型の場合、型引数の数が正しくない場合は即座にパニックします。 *Named型の場合、パニックは後で*Named API内で発生する可能性があります。

func Unalias added in v1.22.0 

func Unalias(t Type) Type

Unaliasは、tがエイリアス型でない場合はtを返し、 それ以外の場合はtのエイリアスチェーンを追跡して エイリアスでない型に到達すると、その型を返します。 その結果、返される結果は決してエイリアス型ではありません。

type TypeAndValue 

type TypeAndValue struct {
	Type  Type
	Value constant.Value
	// contains filtered or unexported fields
}

TypeAndValueは対応する式の型と値（定数の場合）を報告します。

func Eval 

func Eval(fset *token.FileSet, pkg *Package, pos token.Pos, expr string) (_ TypeAndValue, err error)

Evalは、パッケージpkg内の位置posで評価された式exprの型と、定数であれば値を返します。 これは、提供されたファイルセットに対して完全な位置情報を持つASTを型チェックして導出したpkgに関連している必要があります。

fset、pkg、およびposのパラメータの意味は CheckExpr と同じです。exprが正常にパースできないか、結果のexpr ASTが型チェックできない場合はエラーが返されます。

func (TypeAndValue) Addressable 

func (tv TypeAndValue) Addressable() bool

Addressableは、対応する式がアドレス指定可能であるかどうかを報告します（https://golang.org/ref/spec#Address_operators）。

func (TypeAndValue) Assignable 

func (tv TypeAndValue) Assignable() bool

Assignableは、対応する式が（適切な型の値が提供された場合に）代入可能かどうかを報告します。

func (TypeAndValue) HasOk 

func (tv TypeAndValue) HasOk() bool

HasOkは、対応する式がコンマOK代入の右辺に使用できるかどうかを報告します。

func (TypeAndValue) IsBuiltin 

func (tv TypeAndValue) IsBuiltin() bool

IsBuiltinは、対応する式が（たぶん括弧で囲まれた）組み込み関数を示しているかどうかを報告します。

func (TypeAndValue) IsNil 

func (tv TypeAndValue) IsNil() bool

IsNilは、対応する式が事前宣言された値nilを示しているかどうかを報告します。

func (TypeAndValue) IsType 

func (tv TypeAndValue) IsType() bool

IsTypeは、対応する式が型を指定しているかどうかを報告します。

func (TypeAndValue) IsValue 

func (tv TypeAndValue) IsValue() bool

IsValueは、対応する式が値かどうかを報告します。 組み込み関数は値とは見なされません。定数値はnon-nilのValueを持ちます。

func (TypeAndValue) IsVoid 

func (tv TypeAndValue) IsVoid() bool

IsVoid は、対応する式が結果のない関数呼び出しであるかどうかを報告します。

type TypeList added in v1.18.0 

type TypeList struct {
	// contains filtered or unexported fields
}

TypeListは型のリストを保持します。

func (*TypeList) At added in v1.18.0 

func (l *TypeList) At(i int) Type

Atはリスト内のi番目のタイプを返します。

func (*TypeList) Len added in v1.18.0 

func (l *TypeList) Len() int

Lenはリスト内の要素数を返します。 nilの受信側で呼び出しても安全です。

func (*TypeList) Types added in v1.23.0 

func (l *TypeList) Types() iter.Seq[Type]

Types returns a go1.23 iterator over the elements of a list of types.

Example: for t := range l.Types() { ... }

type TypeName 

type TypeName struct {
	// contains filtered or unexported fields
}

TypeNameは(定義済みまたはエイリアスの)型の名前を表します。

func NewTypeName 

func NewTypeName(pos token.Pos, pkg *Package, name string, typ Type) *TypeName

NewTypeNameは、与えられたtypを指定する新しい型名を返します。 残りの引数は、すべてのオブジェクトで見つかった属性を設定します。

typ引数は、定義済み（Named）タイプまたはエイリアスタイプである場合も可能です。 また、nilである場合も、TypeNameを引数として使用でき、 副作用としてTypeNameのタイプがNewNamedに設定されます。

func (*TypeName) IsAlias added in v1.9.0 

func (obj *TypeName) IsAlias() bool

IsAliasは、objが型のエイリアス名であるかどうかを報告します。

func (*TypeName) String 

func (obj *TypeName) String() string

type TypeParam added in v1.18.0 

type TypeParam struct {
	// contains filtered or unexported fields
}

TypeParamは型パラメータータイプを表します。

func (*TypeParam) Constraint added in v1.18.0 

func (t *TypeParam) Constraint() Type

Constraintはtに指定された型制約を返します。

func (*TypeParam) Index added in v1.18.0 

func (t *TypeParam) Index() int

Indexは、タイプパラメータがまだタイプにバインドされていない場合は、そのパラメータリスト内のタイプパラメータのインデックス、または-1を返します。

func (*TypeParam) Obj added in v1.18.0 

func (t *TypeParam) Obj() *TypeName

Obj は型パラメータ t の型名を返します。

func (*TypeParam) SetConstraint added in v1.18.0 

func (t *TypeParam) SetConstraint(bound Type)

SetConstraintはtの型制約を設定します。

これは、boundの基礎が完全に定義された後、NewTypeParamのユーザーによって呼び出される必要があります。 また、他のタイプを形成する以外の方法で、タイプパラメータを使用する前に呼び出す必要があります。 SetConstraintがレシーバを返すと、tは同時使用に安全です。

func (*TypeParam) String added in v1.18.0 

func (t *TypeParam) String() string

func (*TypeParam) Underlying added in v1.18.0 

func (t *TypeParam) Underlying() Type

Underlying returns the underlying type of the type parameter t, which is the underlying type of its constraint. This type is always an interface.

type TypeParamList added in v1.18.0 

type TypeParamList struct {
	// contains filtered or unexported fields
}

TypeParamListは型パラメータのリストを保持します。

func (*TypeParamList) At added in v1.18.0 

func (l *TypeParamList) At(i int) *TypeParam

Atはリスト内のi番目の型パラメータを返します。

func (*TypeParamList) Len added in v1.18.0 

func (l *TypeParamList) Len() int

Lenはリスト内の型パラメーターの数を返します。 nilなレシーバーでも安全に呼び出すことができます。

func (*TypeParamList) TypeParams added in v1.23.0 

func (l *TypeParamList) TypeParams() iter.Seq[*TypeParam]

TypeParams returns a go1.23 iterator over a list of type parameters.

Example: for tparam := range l.TypeParams() { ... }

type Union added in v1.18.0 

type Union struct {
	// contains filtered or unexported fields
}

Unionは、インタフェースに埋め込まれた項のユニオンを表します。

func NewUnion added in v1.18.0 

func NewUnion(terms []*Term) *Union

NewUnionは与えられた要素で新しい Union 型を返します。 空のUnionを作成することはエラーであり、構文的に不可能です。

func (*Union) Len added in v1.18.0 

func (u *Union) Len() int

func (*Union) String added in v1.18.0 

func (u *Union) String() string

func (*Union) Term added in v1.18.0 

func (u *Union) Term(i int) *Term

func (*Union) Terms added in v1.23.0 

func (u *Union) Terms() iter.Seq[*Term]

Terms returns a go1.23 iterator over the terms of a union.

Example: for term := range union.Terms() { ... }

func (*Union) Underlying added in v1.18.0 

func (u *Union) Underlying() Type

type Var 

type Var struct {
	// contains filtered or unexported fields
}

func NewField 

func NewField(pos token.Pos, pkg *Package, name string, typ Type, embedded bool) *Var

NewFieldは、構造体のフィールドを表す新しい変数を返します。 埋め込まれたフィールドの場合、名前はフィールドがアクセス可能な 非修飾の型名です。

func NewParam 

func NewParam(pos token.Pos, pkg *Package, name string, typ Type) *Var

NewParam は関数のパラメータを表す新しい変数を返します。

func NewVar 

func NewVar(pos token.Pos, pkg *Package, name string, typ Type) *Var

NewVarは新しい変数を返します。 引数はすべてのオブジェクトで見つかった属性を設定します。

func (*Var) Anonymous 

func (obj *Var) Anonymous() bool

Anonymousは変数が埋め込まれたフィールドかどうかを示します。 Embeddedと同様ですが、後方互換性のために存在します。

func (*Var) Embedded added in v1.11.0 

func (obj *Var) Embedded() bool

Embeddedは変数が埋め込まれたフィールドかどうかを示します。

func (*Var) IsField 

func (obj *Var) IsField() bool

IsFieldは、変数が構造体のフィールドであるかどうかを報告します。

func (*Var) Origin added in v1.19.0 

func (obj *Var) Origin() *Var

Originは、そのレシーバのための正規のVar、つまりInfo.Defsに記録されたVarオブジェクトを返します。

インスタンス化中に作成された合成Var（型引数に依存する構造体フィールドや 関数パラメータなど）については、これはジェネリック（インスタンス化されていない）型上の 対応するVarになります。他のすべてのVarについて、Originはレシーバを返します。

func (*Var) String 

func (obj *Var) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.