How to use callName method of ast Package

Best Syzkaller code snippet using ast.callName

messages.go

Source:messages.go

...84		call, ok := c.Node().(*ast.CallExpr)85		if !ok {86			return true87		}88		recvName, funcName, callName, argOffset, argPrefix, ok := messagesInfo(call)89		if !ok {90			return true91		}92		_, isFmt := fmtMap[callName]93		isErr := recvName == "errors"94		isLog := strings.HasPrefix(callName, "s.Log") || strings.HasPrefix(callName, "testing.ContextLog")95		// preArgs keeps the arguments before the formatting string.96		var preArgs []argInfo97		for _, a := range call.Args[:argOffset] {98			preArgs = append(preArgs, argInfo{otherArg, "", false, a})99		}100		var args []argInfo101		for _, a := range call.Args[argOffset:] {102			if lit, ok := a.(*ast.BasicLit); ok && lit.Kind == token.STRING {103				val, err := strconv.Unquote(lit.Value)104				if err != nil {105					return true106				}107				args = append(args, argInfo{stringArg, val, false, lit})108			} else if ident, ok := a.(*ast.Ident); ok && ident.Name == "err" {109				// Again, checking the identifier name is unreliable,110				// but getting the actual type here seems hard/impossible.111				// This means that we'll miss error values with other names.112				args = append(args, argInfo{errorArg, "", false, ident})113			} else {114				args = append(args, argInfo{otherArg, "", false, a})115			}116		}117		addIssue := func(msg, link string, fixable bool) {118			issues = append(issues, &Issue{Pos: fs.Position(call.Pos()), Msg: msg, Link: link, Fixable: fixable})119		}120		// Used Logf("Some message") instead of Log("Some message").121		if isFmt && len(args) == 1 {122			// If there is a verb in the string argument, there is a possibility of123			// missing other arguments. If so, define as unfixable and leave as it is.124			fixable := (args[0].typ != stringArg || countVerbs(args[0].val) == 0)125			if !fix {126				addIssue(fmt.Sprintf(`Use %v(%v"<msg>") instead of %v(%v"<msg>")`,127					fmtMap[callName], argPrefix, callName, argPrefix), printfURL, fixable)128			} else if fixable {129				callName = fmtMap[callName]130				funcName = strings.TrimPrefix(callName, recvName+".")131				isFmt = false132			}133		}134		// Used Logf("Got %v", i) instead of Log("Got ", i).135		if !isErr && isFmt && len(args) == 2 && args[0].typ == stringArg && strings.HasSuffix(args[0].val, " %v") {136			if !fix {137				addIssue(fmt.Sprintf(`Use %v(%v"<msg> ", val) instead of %v(%v"<msg> %%v", val)`,138					fmtMap[callName], argPrefix, callName, argPrefix), printfURL, true)139			} else {140				args[0].val = strings.TrimSuffix(args[0].val, "%v")141				args[0].fixed = true142				callName = fmtMap[callName]143				funcName = strings.TrimPrefix(callName, recvName+".")144				isFmt = false145			}146		}147		// Used Log("Some error", err) instead of Log("Some error: ", err).148		if !isFmt && !isErr && len(args) == 2 && args[0].typ == stringArg &&149			args[1].typ == errorArg && !strings.HasSuffix(args[0].val, ": ") {150			if !fix {151				addIssue(fmt.Sprintf(`%v string arg should end with ": " when followed by error`, callName), logFmtURL, true)152			} else {153				// If there are trailing punctuations, it will be checked by lint below,154				// so remove them before adding colon and space.155				// Just a colon or a space should be removed before adding colon and space too.156				args[0].val = strings.TrimRight(args[0].val, ".!: ") + ": "157				args[0].fixed = true158			}159		}160		// Used errors.Errorf("something failed: %v", err) instead of errors.Wrap(err, "something failed").161		if callName == "errors.Errorf" && len(args) >= 2 && args[0].typ == stringArg &&162			args[len(args)-1].typ == errorArg && strings.HasSuffix(args[0].val, "%v") {163			if !fix {164				var formatSuffix, varArgs string165				if len(args) > 2 {166					formatSuffix, varArgs = "f", ", ..."167				}168				addIssue(fmt.Sprintf(`Use errors.Wrap%s(err, "<msg>"%s) instead of errors.Errorf("<msg>: %%v"%s, err)`, formatSuffix, varArgs, varArgs), errPkgURL, true)169			} else {170				funcName = "Wrapf"171				if len(args) == 2 {172					funcName = "Wrap"173					isFmt = false174				}175				callName = recvName + "." + funcName176				args[0].val = strings.TrimRight(strings.TrimSuffix(args[0].val, "%v"), ".!: ")177				args[0].fixed = true178				lastArg := args[len(args)-1]179				args = args[:len(args)-1]180				// Position information may affect the order of expression nodes,181				// so clear it.182				lastArg.node.(*ast.Ident).NamePos = token.NoPos183				preArgs = append(preArgs, lastArg)184			}185		}186		// Used errors.Wrap(err, "something failed: ") instead of errors.Wrap(err, "something failed").187		if callName == "errors.Wrap" && len(args) == 1 && args[0].typ == stringArg &&188			strings.HasSuffix(strings.TrimSpace(args[0].val), ":") {189			messageTrimmed := strings.TrimSuffix(strings.TrimSpace(args[0].val), ":")190			if !fix {191				addIssue(fmt.Sprintf(`Use errors.Wrap(err, "%v") instead of errors.Wrap(err, "%v")`,192					messageTrimmed, args[0].val), errPkgURL, true)193			} else {194				args[0].val = messageTrimmed195				args[0].fixed = true196			}197		}198		// Used errors.Wrapf(err, "something failed: %v", err) instead of errors.Wrap(err, "something failed")199		if callName == "errors.Wrapf" {200			for _, e := range args {201				if e.typ == errorArg {202					addIssue(`Use errors.Wrap(err, "<msg>") instead of errors.Wrapf(err, "<msg>: %v", err)`, errConstURL, true)203					break204				}205			}206		}207		// Used Log(err) instead of Log("Some error: ", err).208		if !isErr && len(args) == 1 && args[0].typ == errorArg {209			addIssue(fmt.Sprintf(`Use %v(%v"Something failed: ", err) instead of %v(%verr)`,210				callName, argPrefix, callName, argPrefix), commonFmtURL, false)211		}212		// Lower-level string checks.213		if len(args) >= 1 && args[0].typ == stringArg && args[0].val != "" {214			// Used Log("Some message.") or Log("Some message!") instead of Log("Some message").215			if strings.LastIndexAny(args[0].val, ".!") == len(args[0].val)-1 {216				if !fix {217					u := logFmtURL218					if isErr {219						u = errFmtURL220					}221					addIssue(fmt.Sprintf("%v string arg should not contain trailing punctuation", callName), u, true)222				} else {223					args[0].val = strings.TrimRight(args[0].val, ".!")224					args[0].fixed = true225				}226			}227			// Used Log("Some message\nMore text") instead of Log("Some message") and Log("More text").228			if strings.Contains(args[0].val, "\n") {229				addIssue(fmt.Sprintf("%v string arg should not contain embedded newlines", callName), commonFmtURL, false)230			}231			// Used Logf("'%s'", ...) instead of Logf("%q", ...).232			if isFmt && invalidQuotedVerbs.MatchString(args[0].val) {233				if !fix {234					addIssue("Use %q to quote values instead of manually quoting them", commonFmtURL, true)235				} else {236					args[0].val = invalidQuotedVerbs.ReplaceAllString(args[0].val, "%q")237					args[0].fixed = true238				}239			}240			// Logs should start with upper letters while errors should start with lower letters.241			// This rule does not apply if messages start with a proper noun, so we check a few242			// hard-coded words only.243			var words = []string{244				"bad",245				"can",246				"can't",247				"cannot",248				"could",249				"couldn't",250				"didn't",251				"error",252				"expected",253				"failed",254				"found",255				"get",256				"getting",257				"got",258				"invalid",259				"no",260				"the",261				"too",262				"unexpected",263				"unknown",264				"unsupported",265			}266			for _, word := range words {267				if !strings.HasPrefix(strings.ToLower(args[0].val), word+" ") {268					continue269				}270				exp := word271				if !isErr {272					exp = strings.ToUpper(word[:1]) + word[1:]273				}274				if strings.HasPrefix(args[0].val, exp) {275					continue276				}277				if !fix {278					if isErr {279						addIssue("Messages of the error type should not be capitalized", formattingURL, true)280					} else if isLog {281						addIssue("Log messages should be capitalized", formattingURL, true)282					} else {283						addIssue("Test failure messages should be capitalized", formattingURL, true)284					}285				} else {286					args[0].val = exp + args[0].val[len(exp):]287					args[0].fixed = true288				}289			}290		}291		// The number of verbs and the number of arguments must match.292		if isFmt && len(args) >= 1 && args[0].typ == stringArg && countVerbs(args[0].val) != len(args)-1 {293			addIssue("The number of verbs in format literal mismatches with the number of arguments", fmtURL, false)294		}295		// Used verbs in non *f families.296		if !isFmt && len(args) >= 1 && args[0].typ == stringArg && hasVerbs(args[0].val) {297			addIssue(fmt.Sprintf("%s has verbs in the first string (do you mean %s?)", callName, fmtMapRev[callName]), formattingURL, false)298		}299		// Error messages should contain some surrounding context.300		if !isLog && len(args) >= 1 && args[0].typ == stringArg && args[0].val == "" {301			addIssue("Error message should have some surrounding context, so must not empty", errFmtURL, false)302		}303		if fix {304			newarg := append(makeCallArgs(preArgs), makeCallArgs(args)...)305			correct := &ast.CallExpr{306				Fun: &ast.SelectorExpr{307					X: &ast.Ident{308						Name:    recvName,309						NamePos: call.Pos(),310					},311					Sel: &ast.Ident{312						Name: funcName,313					},314				},315				Args: newarg,316			}317			c.Replace(correct)318		}319		return true320	}, nil)321	return issues322}323// messagesSprintf checks calls to logging- and error-related functions324// which has fmt.Sprintf argument inside them.325func messagesSprintf(fs *token.FileSet, f *ast.File, fix bool) []*Issue {326	var issues []*Issue327	astutil.Apply(f, func(c *astutil.Cursor) bool {328		call, ok := c.Node().(*ast.CallExpr)329		if !ok {330			return true331		}332		recvName, funcName, callName, argOffset, argPrefix, ok := messagesInfo(call)333		if !ok {334			return true335		}336		_, isFmt := fmtMap[callName]337		// Used Log(fmt.Sprintf(...)) instead of Logf(...)338		if argcall, ok := call.Args[argOffset].(*ast.CallExpr); ok && isFMTSprintf(argcall) && len(call.Args)-argOffset == 1 {339			if !fix {340				msg := ""341				if isFmt {342					msg = fmt.Sprintf(`Use %v(%v...) instead of %v(%vfmt.Sprintf(...))`, callName, argPrefix, callName, argPrefix)343				} else {344					msg = fmt.Sprintf(`Use %v(%v...) instead of %v(%vfmt.Sprintf(...))`, fmtMapRev[callName], argPrefix, callName, argPrefix)345				}346				issues = append(issues, &Issue{347					Pos:     fs.Position(call.Pos()),348					Msg:     msg,349					Link:    printfURL,350					Fixable: true,351				})352			} else {353				newarg := append([]ast.Expr(nil), call.Args[:argOffset]...)354				newarg = append(newarg, argcall.Args...)355				sel := funcName356				if !isFmt {357					sel = strings.TrimPrefix(fmtMapRev[callName], recvName+".")358				}359				correct := &ast.CallExpr{360					Fun: &ast.SelectorExpr{361						X: &ast.Ident{362							Name:    recvName,363							NamePos: call.Pos(),364						},365						Sel: &ast.Ident{366							Name: sel,367						},368					},369					Args: newarg,370				}371				c.Replace(correct)372			}373		}374		return true375	}, nil)376	return issues377}378// messagesInfo returns function name and argument information.379func messagesInfo(call *ast.CallExpr) (recvName, funcName, callName string, argOffset int, argPrefix string, ok bool) {380	argOffset = -1381	sel, ok := call.Fun.(*ast.SelectorExpr)382	if !ok {383		return384	}385	x, ok := sel.X.(*ast.Ident)386	if !ok {387		return388	}389	recvName = x.Name390	funcName = sel.Sel.Name391	callName = recvName + "." + funcName392	switch callName {393	// Just matching a variable name is hacky, but getting the actual type seems394	// very challenging, if not impossible (as ":=" may be used to assign types395	// returned by functions exported by other packages).396	case "s.Log", "s.Logf", "s.Error", "s.Errorf", "s.Fatal", "s.Fatalf", "errors.New", "errors.Errorf":397		argOffset = 0398	case "testing.ContextLog", "testing.ContextLogf":399		argOffset = 1400		argPrefix = "ctx, "401	case "errors.Wrap", "errors.Wrapf":402		argOffset = 1403		argPrefix = "err, "404	default:405		ok = false406	}...

function.go

Source:function.go

1// Copyright 2020 cloudeng llc. All rights reserved.2// Use of this source code is governed by the Apache-2.03// license that can be found in the LICENSE file.4// Package locateutil provides utility routines for use with its parent5// locate package.6package locateutil7import (8	"go/ast"9	"go/token"10	"go/types"11	"regexp"12	"sort"13	"golang.org/x/tools/go/packages"14)15// FuncDesc represents a function definition, declaration and the file16// and position within that file. Decl will be nil if Abstract is true.17type FuncDesc struct {18	Type     *types.Func19	Abstract bool20	Decl     *ast.FuncDecl21	File     *ast.File22	Position token.Position23	Package  *packages.Package24}25// Functions returns the functions in the supplied package that match the26// regular expression. If noMethods is false then methods are also returned.27func Functions(pkg *packages.Package, re *regexp.Regexp, noMethods bool) []FuncDesc {28	descs := []FuncDesc{}29	for k, obj := range pkg.TypesInfo.Defs {30		if obj == nil || !k.IsExported() || !re.MatchString(k.Name) {31			continue32		}33		fn, ok := obj.(*types.Func)34		if !ok {35			continue36		}37		recv := fn.Type().(*types.Signature).Recv()38		abstract := false39		if recv != nil {40			if noMethods {41				continue42			}43			abstract = IsAbstract(fn)44		}45		pos := pkg.Fset.PositionFor(k.Pos(), false)46		var file *ast.File47		for i, v := range pkg.CompiledGoFiles {48			if v == pos.Filename {49				file = pkg.Syntax[i]50			}51		}52		descs = append(descs, FuncDesc{53			Package:  pkg,54			Type:     fn,55			Abstract: abstract,56			Decl:     findFuncOrMethodDecl(fn, file),57			Position: pos,58			File:     file,59		})60	}61	sort.SliceStable(descs, func(i, j int) bool {62		if descs[i].Position.Filename == descs[j].Position.Filename {63			return descs[i].Position.Offset < descs[j].Position.Offset64		}65		return descs[i].Position.Filename < descs[j].Position.Filename66	})67	return descs68}69func findFuncOrMethodDecl(fn *types.Func, file *ast.File) *ast.FuncDecl {70	for _, d := range file.Decls {71		d, ok := d.(*ast.FuncDecl)72		if !ok {73			continue74		}75		if d.Name.NamePos == fn.Pos() {76			return d77		}78	}79	return nil80}81type funcVisitor struct {82	callname *regexp.Regexp83	deferred bool84	nodes    []ast.Node85}86func callMatches(callexpr *ast.CallExpr, callname *regexp.Regexp) bool {87	switch id := callexpr.Fun.(type) {88	case *ast.Ident:89		return callname.MatchString(id.String())90	case *ast.SelectorExpr:91		if sel, ok := id.X.(*ast.Ident); ok {92			return callname.MatchString(sel.String() + "." + id.Sel.String())93		}94	case *ast.CallExpr:95		r := callMatches(id, callname)96		return r97	}98	return false99}100func (v *funcVisitor) Visit(node ast.Node) ast.Visitor {101	if node == nil {102		return nil103	}104	switch n := node.(type) {105	case *ast.DeferStmt:106		if !v.deferred {107			return nil108		}109		if callMatches(n.Call, v.callname) {110			v.nodes = append(v.nodes, node)111		}112	case *ast.ExprStmt:113		if v.deferred {114			return nil115		}116		call, ok := n.X.(*ast.CallExpr)117		if !ok {118			return nil119		}120		if callMatches(call, v.callname) {121			v.nodes = append(v.nodes, node)122		}123	}124	return v125}126// FunctionCalls determines if the supplied function declaration contains a call127// 'callname' where callname is either a function name or a selector (eg. foo.bar).128// If deferred is true the function call must be defer'ed.129func FunctionCalls(decl *ast.FuncDecl, callname *regexp.Regexp, deferred bool) []ast.Node {130	if len(decl.Body.List) == 0 {131		return nil132	}133	v := &funcVisitor{134		callname: callname,135		deferred: deferred,136	}137	ast.Walk(v, decl)138	return v.nodes139}140// FunctionStatements returns number of top-level statements in a function.141func FunctionStatements(decl *ast.FuncDecl) int {142	return len(decl.Body.List)143}144// FunctionHasComment returns true if any of the comments associated or within145// the function contain the specified text.146func FunctionHasComment(decl *ast.FuncDecl, cmap ast.CommentMap, text string) bool {147	if CommentGroupsContain([]*ast.CommentGroup{decl.Doc}, text) {148		return true149	}150	for _, stmt := range decl.Body.List {151		if cg := cmap[stmt]; cg != nil {152			if CommentGroupsContain(cg, text) {153				return true154			}155		}156	}157	return false158}...

builtin.go

Source:builtin.go

1package builders2import "go/ast"3// Make returns make(typ, length) if capacity is less or equal to 0.4// Otherwise, returns make(typ, length, capacity)5func Make(typ ast.Expr, length, capacity int) *ast.CallExpr {6	var c ast.Expr7	if capacity > 0 {8		c = IntegerLit(capacity)9	}10	return MakeExpr(typ, IntegerLit(length), c)11}12// MakeExpr returns make(typ, length) if capacity is nil13// Otherwise, returns make(typ, length, capacity)14func MakeExpr(typ, length, capacity ast.Expr) *ast.CallExpr {15	args := []ast.Expr{typ, length}16	if capacity != nil {17		args = append(args, capacity)18	}19	return CallName("make", args...)20}21// Len returns len(x).22func Len(x ast.Expr) *ast.CallExpr {23	return CallName("len", x)24}25// Cap returns cap(x).26func Cap(x ast.Expr) *ast.CallExpr {27	return CallName("cap", x)28}29// New returns new(x).30func New(x ast.Expr) *ast.CallExpr {31	return CallName("new", x)32}33// Copy returns copy(dst, src).34func Copy(dst, src ast.Expr) *ast.CallExpr {35	return CallName("copy", dst, src)36}37// Append returns append(slice, elem1, elem2, ..., elemN).38func Append(slice ast.Expr, elem ...ast.Expr) *ast.CallExpr {39	args := append([]ast.Expr{slice}, elem...)40	return CallName("append", args...)41}42// Close returns close(ch).43func Close(ch ast.Expr) *ast.CallExpr {44	return CallName("close", ch)45}...

callName

Using AI Code Generation

1func main() {2    a.callName()3}4func main() {5    a.callName()6}7func main() {8    a.callName()9}10func main() {11    a.callName()12}13func main() {14    a.callName()15}16func main() {17    a.callName()18}19func main() {20    a.callName()21}22func main() {23    a.callName()24}25func main() {26    a.callName()27}28func main() {29    a.callName()30}31func main() {32    a.callName()33}34func main() {35    a.callName()36}37func main() {38    a.callName()39}40func main() {41    a.callName()42}

callName

Using AI Code Generation

1import "fmt"2type ast struct {3}4func (a ast) callName() {5fmt.Println("Name:", a.name)6}7func main() {8a := ast{name: "Gopher"}9a.callName()10}11import "fmt"12type ast struct {13}14func (a *ast) callName() {15fmt.Println("Name:", a.name)16}17func main() {18a := ast{name: "Go"}19a.callName()20}21import "fmt"22type ast struct {23}24func (a *ast) callName() {25fmt.Println("Name:", a.name)26}27func main() {28a := ast{name: "Go"}29}

callName

Using AI Code Generation

1import "fmt"2type ast struct {3}4func (a ast) callName() {5	fmt.Println(a.name)6}7func main() {8	a := ast{"Ast"}9	a.callName()10}

callName

Using AI Code Generation

1import "fmt"2func main() {3    a.callName()4}5type ast struct {}6func (a ast) callName() {7    fmt.Println("Hello World")8}

callName

Using AI Code Generation

1import "fmt"2func main(){3ast := astClass{}4ast.callName()5}6import "fmt"7type astClass struct{8}9func (ast *astClass) callName(){10fmt.Println(ast.name)11}12if (variable != "" || variable != " " || variable != "  " || variable != "   " || variable != "    ") {13}14import (15func main() {16    var a interface{}17    fmt.Println(reflect.TypeOf(a))18    fmt.Println(reflect.TypeOf(a).Kind())19}20import (21func main() {22    wg.Add(1)23    go func() {24        defer wg.Done()25        time.Sleep(time.Second * 10)26        fmt.Println("Hello")27    }()28    wg.Wait()29}30sync.runtime_Semacquire(0xc4200141b4)31sync.(*WaitGroup).Wait(0xc4200141a8)32main.main()33main.main.func1(0xc4200141a8)

callName

Using AI Code Generation

1import "fmt"2import "os"3import "bufio"4import "strings"5import "strconv"6import "time"7import "runtime"8import "math"9import "math/rand"10import "unicode"11import "unicode/utf8"12import "container/vector"13import "container/list"14import "container/ring"15import "container/heap"16import "container/stack"17import "container/tree"18import "container/priority_queue"19import "container/queue"20import "container/set"21import "container/trie"22import "container/stack"23import "container/queue"24import "container/heap"25import "container/vector"26import "container/list"27import "container/ring"28import "container/set"29import "container/trie"30import "container/stack"31import "container/queue"32import "container/heap"33import "container/vector"34import "container/list"35import "container/ring"36import "container/set"37import "container/trie"38import "container/stack"39import "container/queue"40import "container/heap"41import "container/vector"42import "container/list"43import "container/ring"44import "container/set"45import "container/trie"46import "container/stack"47import "container/queue"48import "container/heap"49import "container/vector"50import "container/list"51import "container/ring"52import "container/set"53import "container/trie"54import "container/stack"55import "container/queue"56import "container/heap"57import "container/vector"58import "container/list"59import "container/ring"60import "container/set"61import "container/trie"62import "container/stack"63import "container/queue"64import "container/heap"65import "container/vector"66import "container/list"67import "container/ring"68import "container/set"69import "container/trie"70import "container/stack"71import "container/queue"72import "container/heap"73import "container/vector"74import "container/list"75import "container/ring"76import "container/set"77import "container/trie"78import "container/stack"79import "container/queue"80import "container/heap"81import "container/vector"82import "container/list"83import "container/ring"84import "container/set"85import "container/trie"86import "container/stack"87import "container/queue"88import "container/heap"89import

callName

Using AI Code Generation

1import "fmt"2func main() {3    a := ast{Name: "John", Age: 23}4    fmt.Println(a.callName())5}6import "fmt"7func main() {8    a := ast{Name: "John", Age: 23}9    fmt.Println(a.callAge())10}11import "fmt"12func main() {13    a := ast{Name: "John", Age: 23}14    fmt.Println(a.callAge())15}16import "fmt"17func main() {18    a := ast{Name: "John", Age: 23}19    fmt.Println(a.callAge())20}21import "fmt"22func main() {23    a := ast{Name: "John", Age: 23}24    fmt.Println(a.callAge())25}26import "fmt"27func main() {28    a := ast{Name: "John", Age: 23}29    fmt.Println(a.callAge())30}31import "fmt"32func main() {33    a := ast{Name: "John", Age: 23}34    fmt.Println(a.callAge())35}36import "fmt"37func main() {38    a := ast{Name: "John", Age: 23}39    fmt.Println(a.callAge())40}41import "fmt"42func main() {43    a := ast{Name: "John", Age: 23}44    fmt.Println(a.callAge())45}46import "fmt"47func main() {48    a := ast{Name: "John", Age: 23}49    fmt.Println(a.callAge())50}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.