type go/ast.Ident
154 uses
go/ast (current package)
ast.go#L198: Names []*Ident // field/method/(type) parameter names; or nil
ast.go#L287: Ident struct {
ast.go#L333: Sel *Ident // field selector
ast.go#L483: func (x *Ident) Pos() token.Pos { return x.NamePos }
ast.go#L517: func (x *Ident) End() token.Pos { return token.Pos(int(x.NamePos) + len(x.Name)) }
ast.go#L554: func (*Ident) exprNode() {}
ast.go#L584: func NewIdent(name string) *Ident { return &Ident{token.NoPos, name, nil} }
ast.go#L592: func (id *Ident) IsExported() bool { return token.IsExported(id.Name) }
ast.go#L594: func (id *Ident) String() string {
ast.go#L632: Label *Ident
ast.go#L692: Label *Ident // label name; or nil
ast.go#L896: Name *Ident // local package name (including "."); or nil
ast.go#L907: Names []*Ident // value names (len(Names) > 0)
ast.go#L916: Name *Ident // type name
ast.go#L995: Name *Ident // function/method name
ast.go#L1053: Name *Ident // package name
ast.go#L1057: Unresolved []*Ident // unresolved identifiers in this file
commentmap.go#L331: if ident, ok := node.(*Ident); ok {
filter.go#L48: func filterIdentList(list []*Ident, f Filter) []*Ident {
filter.go#L63: func fieldName(x Expr) *Ident {
filter.go#L65: case *Ident:
filter.go#L68: if _, ok := t.X.(*Ident); ok {
filter.go#L127: if x, ok := x.Key.(*Ident); ok && !filter(x.Name) {
filter.go#L155: case *Ident:
filter.go#L328: if p, _ := t.(*Ident); p != nil {
resolve.go#L44: func resolve(scope *Scope, ident *Ident) bool {
scope.go#L126: if ident, isIdent := x.(*Ident); isIdent && ident.Name == name {
walk.go#L18: func walkIdentList(v Visitor, list []*Ident) {
walk.go#L90: case *BadExpr, *Ident, *BasicLit:
go/doc
example.go#L199: case *ast.Ident:
exports.go#L17: func filterIdentList(list []*ast.Ident) []*ast.Ident {
exports.go#L45: if x, ok := x.Key.(*ast.Ident); ok && !filter(x.Name) {
exports.go#L60: func updateIdentList(list []*ast.Ident) (hasExported bool) {
exports.go#L73: func hasExportedName(list []*ast.Ident) bool {
exports.go#L177: case *ast.Ident:
exports.go#L261: case *ast.Ident:
exports.go#L262: return &ast.Ident{Name: typ.Name, NamePos: pos}
exports.go#L264: if id, ok := typ.X.(*ast.Ident); ok {
exports.go#L268: X: &ast.Ident{Name: id.Name, NamePos: pos},
reader.go#L32: case *ast.Ident:
reader.go#L58: if id, ok := p.(*ast.Ident); ok {
reader.go#L128: case *ast.Ident:
reader.go#L135: if _, ok := t.X.(*ast.Ident); ok {
reader.go#L482: func lookupTypeParam(name string, tparams *ast.FieldList) *ast.Ident {
reader.go#L672: newIdent := &ast.Ident{NamePos: origPos, Name: recvTypeName}
go/parser
interface.go#L111: Name: new(ast.Ident),
parser.go#L423: func (p *parser) parseIdent() *ast.Ident {
parser.go#L432: return &ast.Ident{NamePos: pos, Name: name}
parser.go#L435: func (p *parser) parseIdentList() (list []*ast.Ident) {
parser.go#L495: func (p *parser) parseQualifiedIdent(ident *ast.Ident) ast.Expr {
parser.go#L509: func (p *parser) parseTypeName(ident *ast.Ident) ast.Expr {
parser.go#L558: func (p *parser) parseArrayFieldOrTypeInstance(x *ast.Ident) (*ast.Ident, ast.Expr) {
parser.go#L623: var names []*ast.Ident
parser.go#L635: names = []*ast.Ident{name}
parser.go#L720: name *ast.Ident
parser.go#L724: func (p *parser) parseParamDecl(name *ast.Ident, typeSetsOK bool) (f field) {
parser.go#L807: func (p *parser) parseParameterList(name0 *ast.Ident, typ0 ast.Expr, closing token.Token) (params []*ast.Field) {
parser.go#L913: var names []*ast.Ident
parser.go#L1009: var idents []*ast.Ident
parser.go#L1012: if ident, _ := x.(*ast.Ident); ident != nil {
parser.go#L1021: if name0, _ := x.(*ast.Ident); name0 != nil && p.tok != token.COMMA && p.tok != token.RBRACK {
parser.go#L1033: idents = []*ast.Ident{ident}
parser.go#L1063: idents = []*ast.Ident{ident}
parser.go#L1383: _, isIdent := typ.(*ast.Ident)
parser.go#L1605: case *ast.Ident:
parser.go#L1687: sel := &ast.Ident{NamePos: pos, Name: "_"}
parser.go#L1700: case *ast.BadExpr, *ast.Ident, *ast.SelectorExpr:
parser.go#L1932: if label, isIdent := x[0].(*ast.Ident); mode == labelOk && isIdent {
parser.go#L1968: if _, isIdent := x.(*ast.Ident); !isIdent {
parser.go#L2038: var label *ast.Ident
parser.go#L2508: var ident *ast.Ident
parser.go#L2511: ident = &ast.Ident{NamePos: p.pos, Name: "."}
parser.go#L2579: func (p *parser) parseGenericType(spec *ast.TypeSpec, openPos token.Pos, name0 *ast.Ident, typ0 ast.Expr) {
parser.go#L2638: var pname *ast.Ident // pname != nil means pname is the type parameter name
parser.go#L2642: case *ast.Ident:
parser.go#L2653: if name, _ := t.X.(*ast.Ident); name != nil {
parser.go#L2671: if name, _ := t.Fun.(*ast.Ident); name != nil {
resolver.go#L64: unresolved []*ast.Ident // unresolved identifiers
resolver.go#L70: targetStack [][]*ast.Ident // stack of unresolved labels
resolver.go#L123: func (r *resolver) declare(decl, data any, scope *ast.Scope, kind ast.ObjKind, idents ...*ast.Ident) {
resolver.go#L135: if _, ok := decl.(*ast.Ident); !ok {
resolver.go#L159: if ident, isIdent := x.(*ast.Ident); isIdent {
resolver.go#L192: func (r *resolver) resolve(ident *ast.Ident, collectUnresolved bool) {
resolver.go#L209: if _, ok := obj.Decl.(*ast.Ident); !ok {
resolver.go#L234: if _, ok := expr.(*ast.Ident); !ok && expr != nil {
resolver.go#L254: case *ast.Ident:
resolver.go#L287: if ident, _ := kv.Key.(*ast.Ident); ident != nil {
resolver.go#L564: if id, _ := expr.(*ast.Ident); id != nil {
go/printer
nodes.go#L108: func (p *printer) identList(list []*ast.Ident, indent bool) {
nodes.go#L443: func identListSize(list []*ast.Ident, maxSize int) (size int) {
nodes.go#L580: var prev *ast.Ident // previous "type" identifier
nodes.go#L582: var name *ast.Ident // first name, or nil
nodes.go#L800: case *ast.Ident:
nodes.go#L1184: case *ast.Ident:
printer.go#L932: case *ast.Ident:
go/types
api.go#L214: Instances map[*ast.Ident]Instance
api.go#L225: Defs map[*ast.Ident]Object
api.go#L232: Uses map[*ast.Ident]Object
api.go#L290: if id, _ := e.(*ast.Ident); id != nil {
api.go#L306: func (info *Info) ObjectOf(id *ast.Ident) Object {
assignments.go#L174: ident, _ := unparen(lhs).(*ast.Ident)
assignments.go#L419: ident, _ := lhs.(*ast.Ident)
call.go#L445: if ident, ok := e.X.(*ast.Ident); ok {
call.go#L753: if ident, _ := unparen(e).(*ast.Ident); ident != nil {
check.go#L126: recvTParamMap map[*ast.Ident]*TypeParam // maps blank receiver type parameters to their type
check.go#L469: case *ast.Ident, *ast.SelectorExpr:
check.go#L520: func instantiatedIdent(expr ast.Expr) *ast.Ident {
check.go#L527: case *ast.SelectorExpr, *ast.Ident:
check.go#L531: case *ast.Ident:
check.go#L539: func (check *Checker) recordDef(id *ast.Ident, obj Object) {
check.go#L546: func (check *Checker) recordUse(id *ast.Ident, obj Object) {
decl.go#L23: func (check *Checker) declare(scope *Scope, id *ast.Ident, obj Object, pos token.Pos) {
decl.go#L674: func (check *Checker) declareTypeParams(tparams []*TypeParam, names []*ast.Ident) []*TypeParam {
expr.go#L515: case *ast.Ident, *ast.BasicLit, *ast.SelectorExpr:
expr.go#L1256: case *ast.Ident:
expr.go#L1374: key, _ := kv.Key.(*ast.Ident)
exprstring.go#L38: case *ast.Ident:
exprstring.go#L219: func writeIdentList(buf *bytes.Buffer, list []*ast.Ident) {
resolver.go#L103: func (check *Checker) declarePkgObj(ident *ast.Ident, obj Object, d *declInfo) {
resolver.go#L227: recv *ast.Ident // receiver type name
resolver.go#L497: func (check *Checker) unpackRecv(rtyp ast.Expr, unpackParams bool) (ptr bool, rname *ast.Ident, tparams []*ast.Ident) {
resolver.go#L521: var par *ast.Ident
resolver.go#L523: case *ast.Ident:
resolver.go#L533: par = &ast.Ident{NamePos: arg.Pos(), Name: "_"}
resolver.go#L541: if name, _ := rtyp.(*ast.Ident); name != nil {
resolver.go#L552: func (check *Checker) resolveBaseTypeName(seenPtr bool, name *ast.Ident) (ptr bool, base *TypeName) {
resolver.go#L575: name, _ := typ.(*ast.Ident)
signature.go#L127: check.recvTParamMap = make(map[*ast.Ident]*TypeParam)
stmt.go#L277: if name, _ := unparen(e).(*ast.Ident); name != nil {
stmt.go#L605: x.expr = &ast.Ident{NamePos: s.Body.Lbrace, Name: "true"}
stmt.go#L644: var lhs *ast.Ident // lhs identifier or nil
stmt.go#L655: lhs, _ = guard.Lhs[0].(*ast.Ident)
stmt.go#L880: if ident, _ := lhs.(*ast.Ident); ident != nil {
struct.go#L84: add := func(ident *ast.Ident, embedded bool, pos token.Pos) {
struct.go#L105: addInvalid := func(ident *ast.Ident, pos token.Pos) {
struct.go#L179: func embeddedFieldIdent(e ast.Expr) *ast.Ident {
struct.go#L181: case *ast.Ident:
typexpr.go#L22: func (check *Checker) ident(x *operand, e *ast.Ident, def *Named, wantType bool) {
typexpr.go#L242: case *ast.Ident:
typexpr.go#L502: if name, _ := e.(*ast.Ident); name != nil {
golang.org/x/tools/go/packages
packages.go#L997: Defs: make(map[*ast.Ident]types.Object),
packages.go#L998: Uses: make(map[*ast.Ident]types.Object),
golang.org/x/tools/internal/typeparams
typeparams_go118.go#L129: info.Instances = make(map[*ast.Ident]types.Instance)
typeparams_go118.go#L136: func GetInstances(info *types.Info) map[*ast.Ident]Instance {
gotest.tools/v3/internal/assert
assert.go#L152: if ident, ok := expr.(*ast.Ident); ok {
result.go#L102: case *ast.Ident, *ast.SelectorExpr, *ast.IndexExpr, *ast.SliceExpr:
gotest.tools/v3/internal/source
update.go#L83: ident *ast.Ident,
update.go#L141: func getIdentForExpectedValueArg(expr []ast.Expr) (int, *ast.Ident) {
update.go#L144: case *ast.Ident: