type go/ast.Expr

200 uses

	go/ast (current package)
		ast.go#L39: type Expr interface {
		ast.go#L200: 	Type    Expr          // field/method/parameter type
		ast.go#L289: 		Elt      Expr      // ellipsis element type (parameter lists only); or nil
		ast.go#L313: 		Type       Expr      // literal type; or nil
		ast.go#L315: 		Elts       []Expr    // list of composite elements; or nil
		ast.go#L323: 		X      Expr      // parenthesized expression
		ast.go#L329: 		X   Expr   // expression
		ast.go#L335: 		X      Expr      // expression
		ast.go#L337: 		Index  Expr      // index expression
		ast.go#L343: 		X      Expr      // expression
		ast.go#L345: 		Low    Expr      // begin of slice range; or nil
		ast.go#L346: 		High   Expr      // end of slice range; or nil
		ast.go#L347: 		Max    Expr      // maximum capacity of slice; or nil
		ast.go#L356: 		X      Expr      // expression
		ast.go#L358: 		Type   Expr      // asserted type; nil means type switch X.(type)
		ast.go#L364: 		Fun      Expr      // function expression
		ast.go#L366: 		Args     []Expr    // function arguments; or nil
		ast.go#L376: 		X    Expr      // operand
		ast.go#L385: 		X     Expr        // operand
		ast.go#L390: 		X     Expr        // left operand
		ast.go#L393: 		Y     Expr        // right operand
		ast.go#L400: 		Key   Expr
		ast.go#L402: 		Value Expr
		ast.go#L424: 		Len    Expr      // Ellipsis node for [...]T array types, nil for slice types
		ast.go#L425: 		Elt    Expr      // element type
		ast.go#L454: 		Key   Expr
		ast.go#L455: 		Value Expr
		ast.go#L463: 		Value Expr      // value type
		ast.go#L625: 		X Expr // expression
		ast.go#L630: 		Chan  Expr
		ast.go#L632: 		Value Expr
		ast.go#L637: 		X      Expr
		ast.go#L646: 		Lhs    []Expr
		ast.go#L649: 		Rhs    []Expr
		ast.go#L667: 		Results []Expr    // result expressions; or nil
		ast.go#L690: 		Cond Expr      // condition
		ast.go#L698: 		List  []Expr    // list of expressions or types; nil means default case
		ast.go#L707: 		Tag    Expr       // tag expression; or nil
		ast.go#L737: 		Cond Expr      // condition; or nil
		ast.go#L745: 		Key, Value Expr        // Key, Value may be nil
		ast.go#L748: 		X          Expr        // value to range over
		ast.go#L892: 		Type    Expr          // value type; or nil
		ast.go#L893: 		Values  []Expr        // initial values; or nil
		ast.go#L902: 		Type    Expr          // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes
		filter.go#L63: func fieldName(x Expr) *Ident {
		filter.go#L120: func filterExprList(list []Expr, filter Filter, export bool) []Expr {
		filter.go#L153: func filterType(typ Expr, f Filter, export bool) bool {
		walk.go#L24: func walkExprList(v Visitor, list []Expr) {

	go/doc
		exports.go#L38: func filterExprList(list []ast.Expr, filter Filter, export bool) []ast.Expr {
		exports.go#L169: func (r *reader) filterType(parent *namedType, typ ast.Expr) {
		exports.go#L237: func copyConstType(typ ast.Expr, pos token.Pos) ast.Expr {
		exports.go#L257: 		var prevType ast.Expr
		reader.go#L28: func recvString(recv ast.Expr) string {
		reader.go#L56: 		var typ ast.Expr
		reader.go#L100: func baseTypeName(x ast.Expr) (name string, imported bool) {
		reader.go#L203: func (r *reader) recordAnonymousField(parent *namedType, fieldType ast.Expr) (fname string) {
		reader.go#L318: func fields(typ ast.Expr) (list []*ast.Field, isStruct bool) {
		reader.go#L619: 	var typ ast.Expr = newIdent

	go/parser
		interface.go#L186: func ParseExprFrom(fset *token.FileSet, filename string, src interface{}, mode Mode) (expr ast.Expr, err error) {
		interface.go#L239: func ParseExpr(x string) (ast.Expr, error) {
		parser.go#L140: func (p *parser) shortVarDecl(decl *ast.AssignStmt, list []ast.Expr) {
		parser.go#L178: func (p *parser) tryResolve(x ast.Expr, collectUnresolved bool) {
		parser.go#L205: func (p *parser) resolve(x ast.Expr) {
		parser.go#L576: func (p *parser) parseExprList(lhs bool) (list []ast.Expr) {
		parser.go#L590: func (p *parser) parseLhsList() []ast.Expr {
		parser.go#L618: func (p *parser) parseRhsList() []ast.Expr {
		parser.go#L629: func (p *parser) parseType() ast.Expr {
		parser.go#L647: func (p *parser) parseTypeName() ast.Expr {
		parser.go#L666: func (p *parser) parseArrayType() ast.Expr {
		parser.go#L673: 	var len ast.Expr
		parser.go#L688: func (p *parser) makeIdentList(list []ast.Expr) []*ast.Ident {
		parser.go#L713: 	var list []ast.Expr
		parser.go#L796: func (p *parser) tryVarType(isParam bool) ast.Expr {
		parser.go#L813: func (p *parser) parseVarType(isParam bool) ast.Expr {
		parser.go#L831: 	var list []ast.Expr
		parser.go#L947: 	var typ ast.Expr
		parser.go#L1032: func (p *parser) tryIdentOrType() ast.Expr {
		parser.go#L1063: func (p *parser) tryType() ast.Expr {
		parser.go#L1119: func (p *parser) parseFuncTypeOrLit() ast.Expr {
		parser.go#L1141: func (p *parser) parseOperand(lhs bool) ast.Expr {
		parser.go#L1186: func (p *parser) parseSelector(x ast.Expr) ast.Expr {
		parser.go#L1196: func (p *parser) parseTypeAssertion(x ast.Expr) ast.Expr {
		parser.go#L1202: 	var typ ast.Expr
		parser.go#L1214: func (p *parser) parseIndexOrSlice(x ast.Expr) ast.Expr {
		parser.go#L1222: 	var index [N]ast.Expr
		parser.go#L1261: func (p *parser) parseCallOrConversion(fun ast.Expr) *ast.CallExpr {
		parser.go#L1268: 	var list []ast.Expr
		parser.go#L1287: func (p *parser) parseValue(keyOk bool) ast.Expr {
		parser.go#L1329: func (p *parser) parseElement() ast.Expr {
		parser.go#L1344: func (p *parser) parseElementList() (list []ast.Expr) {
		parser.go#L1360: func (p *parser) parseLiteralValue(typ ast.Expr) ast.Expr {
		parser.go#L1366: 	var elts []ast.Expr
		parser.go#L1377: func (p *parser) checkExpr(x ast.Expr) ast.Expr {
		parser.go#L1408: func isTypeName(x ast.Expr) bool {
		parser.go#L1422: func isLiteralType(x ast.Expr) bool {
		parser.go#L1439: func deref(x ast.Expr) ast.Expr {
		parser.go#L1447: func unparen(x ast.Expr) ast.Expr {
		parser.go#L1457: func (p *parser) checkExprOrType(x ast.Expr) ast.Expr {
		parser.go#L1473: func (p *parser) parsePrimaryExpr(lhs bool) ast.Expr {
		parser.go#L1528: func (p *parser) parseUnaryExpr(lhs bool) ast.Expr {
		parser.go#L1606: func (p *parser) parseBinaryExpr(lhs bool, prec1 int) ast.Expr {
		parser.go#L1631: func (p *parser) parseExpr(lhs bool) ast.Expr {
		parser.go#L1639: func (p *parser) parseRhs() ast.Expr {
		parser.go#L1647: func (p *parser) parseRhsOrType() ast.Expr {
		parser.go#L1685: 		var y []ast.Expr
		parser.go#L1690: 			y = []ast.Expr{&ast.UnaryExpr{OpPos: pos, Op: token.RANGE, X: p.parseRhs()}}
		parser.go#L1796: 	var x []ast.Expr
		parser.go#L1823: func (p *parser) makeExpr(s ast.Stmt, want string) ast.Expr {
		parser.go#L1841: func (p *parser) parseIfHeader() (init ast.Stmt, cond ast.Expr) {
		parser.go#L1933: func (p *parser) parseTypeList() (list []ast.Expr) {
		parser.go#L1953: 	var list []ast.Expr
		parser.go#L1973: func isTypeSwitchAssert(x ast.Expr) bool {
		parser.go#L2090: 				as := &ast.AssignStmt{Lhs: lhs, TokPos: pos, Tok: tok, Rhs: []ast.Expr{rhs}}
		parser.go#L2152: 				y := []ast.Expr{&ast.UnaryExpr{OpPos: pos, Op: token.RANGE, X: p.parseRhs()}}
		parser.go#L2180: 		var key, value ast.Expr
		parser.go#L2338: 	var values []ast.Expr

	go/printer
		nodes.go#L110: 	xlist := make([]ast.Expr, len(list))
		nodes.go#L130: func (p *printer) exprList(prev0 token.Pos, list []ast.Expr, depth int, mode exprListMode, next0 token.Pos, isIncomplete bool) {
		nodes.go#L644: func diffPrec(expr ast.Expr, prec int) int {
		nodes.go#L735: func isBinary(expr ast.Expr) bool {
		nodes.go#L740: func (p *printer) expr1(expr ast.Expr, prec1, depth int) {
		nodes.go#L841: 		indices := []ast.Expr{x.Low, x.High}
		nodes.go#L1037: func (p *printer) possibleSelectorExpr(expr ast.Expr, prec1, depth int) bool {
		nodes.go#L1061: func (p *printer) expr0(x ast.Expr, depth int) {
		nodes.go#L1065: func (p *printer) expr(x ast.Expr) {
		nodes.go#L1121: func isTypeName(x ast.Expr) bool {
		nodes.go#L1131: func stripParens(x ast.Expr) ast.Expr {
		nodes.go#L1157: func stripParensAlways(x ast.Expr) ast.Expr {
		nodes.go#L1164: func (p *printer) controlClause(isForStmt bool, init ast.Stmt, expr ast.Expr, post ast.Stmt) {
		nodes.go#L1202: func (p *printer) indentList(list []ast.Expr) bool {
		printer.go#L1127: 	case ast.Expr:

	golang.org/x/pkgsite/internal/godoc
		encode_ast.gen.go#L56: 			x.Len = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L58: 			x.Elt = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L412: 			x.X = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L418: 			x.Y = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L605: 			x.Fun = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L747: 			x.Value = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L983: 			x.Type = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L1150: 			x.Elt = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L1254: 			x.X = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L1384: 			x.Type = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L1457: 			x.Cond = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L1914: 			x.Cond = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2048: 			x.X = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2113: 			x.X = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2117: 			x.Index = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2237: 			x.Key = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2241: 			x.Value = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2361: 			x.Key = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2363: 			x.Value = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2422: 			x.X = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2499: 			x.Key = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2501: 			x.Value = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2507: 			x.X = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2727: 			x.X = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2786: 			x.Chan = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2790: 			x.Value = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2863: 			x.X = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2867: 			x.Low = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2869: 			x.High = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2871: 			x.Max = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L2930: 			x.X = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L3056: 			x.Tag = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L3119: 			x.X = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L3123: 			x.Type = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L3196: 			x.Type = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L3326: 			x.X = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L3395: 			x.Type = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L3473: func encode_slice_ast_Expr(e *codec.Encoder, s []ast.Expr) {
		encode_ast.gen.go#L3484: func decode_slice_ast_Expr(d *codec.Decoder, p *[]ast.Expr) {
		encode_ast.gen.go#L3489: 	s := make([]ast.Expr, n)
		encode_ast.gen.go#L3491: 		s[i] = d.DecodeAny().(ast.Expr)
		encode_ast.gen.go#L3497: 	codec.Register([]ast.Expr(nil),
		encode_ast.gen.go#L3498: 		func(e *codec.Encoder, x interface{}) { encode_slice_ast_Expr(e, x.([]ast.Expr)) },
		encode_ast.gen.go#L3499: 		func(d *codec.Decoder) interface{} { var x []ast.Expr; decode_slice_ast_Expr(d, &x); return x })

	golang.org/x/pkgsite/internal/godoc/internal/doc
		exports.go#L38: func filterExprList(list []ast.Expr, filter Filter, export bool) []ast.Expr {
		exports.go#L169: func (r *reader) filterType(parent *namedType, typ ast.Expr) {
		exports.go#L237: func copyConstType(typ ast.Expr, pos token.Pos) ast.Expr {
		exports.go#L257: 		var prevType ast.Expr
		reader.go#L28: func recvString(recv ast.Expr) string {
		reader.go#L56: 		var typ ast.Expr
		reader.go#L102: func baseTypeName(x ast.Expr) (name string, imported bool) {
		reader.go#L205: func (r *reader) recordAnonymousField(parent *namedType, fieldType ast.Expr) (fname string) {
		reader.go#L322: func fields(typ ast.Expr) (list []*ast.Field, isStruct bool) {
		reader.go#L623: 	var typ ast.Expr = newIdent