Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use Format method of ast Package

Best Syzkaller code snippet using ast.Format

stmt_expr_or_type.go

Source:stmt_expr_or_type.go

1/*2 * Copyright (c) 2021 The GoPlus Authors (goplus.org). All rights reserved.3 *4 * Licensed under the Apache License, Version 2.0 (the "License");5 * you may not use this file except in compliance with the License.6 * You may obtain a copy of the License at7 *8 *     http://www.apache.org/licenses/LICENSE-2.09 *10 * Unless required by applicable law or agreed to in writing, software11 * distributed under the License is distributed on an "AS IS" BASIS,12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.13 * See the License for the specific language governing permissions and14 * limitations under the License.15 */16package format17import (18	"go/token"19	"log"20	"reflect"21	"github.com/goplus/gop/ast"22)23// -----------------------------------------------------------------------------24func formatType(ctx *formatCtx, typ ast.Expr, ref *ast.Expr) {25	switch t := typ.(type) {26	case *ast.Ident, nil:27	case *ast.SelectorExpr:28		formatSelectorExpr(ctx, t, ref)29	case *ast.StarExpr:30		formatType(ctx, t.X, &t.X)31	case *ast.MapType:32		formatType(ctx, t.Key, &t.Key)33		formatType(ctx, t.Value, &t.Value)34	case *ast.StructType:35		formatFields(ctx, t.Fields)36	case *ast.ArrayType:37		formatExpr(ctx, t.Len, &t.Len)38		formatType(ctx, t.Elt, &t.Elt)39	case *ast.ChanType:40		formatType(ctx, t.Value, &t.Value)41	case *ast.InterfaceType:42		formatFields(ctx, t.Methods)43	case *ast.FuncType:44		formatFuncType(ctx, t)45	case *ast.Ellipsis:46		formatType(ctx, t.Elt, &t.Elt)47	default:48		log.Panicln("TODO: format -", reflect.TypeOf(typ))49	}50}51func formatFuncType(ctx *formatCtx, t *ast.FuncType) {52	formatFields(ctx, t.Params)53	formatFields(ctx, t.Results)54}55func formatFields(ctx *formatCtx, flds *ast.FieldList) {56	if flds != nil {57		for _, fld := range flds.List {58			formatField(ctx, fld)59		}60	}61}62func formatField(ctx *formatCtx, fld *ast.Field) {63	formatType(ctx, fld.Type, &fld.Type)64}65// -----------------------------------------------------------------------------66func formatExprs(ctx *formatCtx, exprs []ast.Expr) {67	for i, expr := range exprs {68		formatExpr(ctx, expr, &exprs[i])69	}70}71func formatExpr(ctx *formatCtx, expr ast.Expr, ref *ast.Expr) {72	switch v := expr.(type) {73	case *ast.Ident, *ast.BasicLit, *ast.BadExpr, nil:74	case *ast.BinaryExpr:75		formatExpr(ctx, v.X, &v.X)76		formatExpr(ctx, v.Y, &v.Y)77	case *ast.UnaryExpr:78		formatExpr(ctx, v.X, &v.X)79	case *ast.CallExpr:80		formatCallExpr(ctx, v)81	case *ast.SelectorExpr:82		formatSelectorExpr(ctx, v, ref)83	case *ast.SliceExpr:84		formatSliceExpr(ctx, v)85	case *ast.IndexExpr:86		formatExpr(ctx, v.X, &v.X)87		formatExpr(ctx, v.Index, &v.Index)88	case *ast.SliceLit:89		formatExprs(ctx, v.Elts)90	case *ast.CompositeLit:91		formatType(ctx, v.Type, &v.Type)92		formatExprs(ctx, v.Elts)93	case *ast.StarExpr:94		formatExpr(ctx, v.X, &v.X)95	case *ast.KeyValueExpr:96		formatExpr(ctx, v.Key, &v.Key)97		formatExpr(ctx, v.Value, &v.Value)98	case *ast.FuncLit:99		formatFuncType(ctx, v.Type)100		formatBlockStmt(ctx, v.Body)101	case *ast.TypeAssertExpr:102		formatExpr(ctx, v.X, &v.X)103		formatType(ctx, v.Type, &v.Type)104	case *ast.LambdaExpr:105		formatExprs(ctx, v.Rhs)106	case *ast.LambdaExpr2:107		formatBlockStmt(ctx, v.Body)108	case *ast.RangeExpr:109		formatRangeExpr(ctx, v)110	case *ast.ComprehensionExpr:111		formatComprehensionExpr(ctx, v)112	case *ast.ErrWrapExpr:113		formatExpr(ctx, v.X, &v.X)114		formatExpr(ctx, v.Default, &v.Default)115	case *ast.ParenExpr:116		formatExpr(ctx, v.X, &v.X)117	case *ast.Ellipsis:118		formatExpr(ctx, v.Elt, &v.Elt)119	default:120		formatType(ctx, expr, ref)121	}122}123func formatRangeExpr(ctx *formatCtx, v *ast.RangeExpr) {124	formatExpr(ctx, v.First, &v.First)125	formatExpr(ctx, v.Last, &v.Last)126	formatExpr(ctx, v.Expr3, &v.Expr3)127}128func formatComprehensionExpr(ctx *formatCtx, v *ast.ComprehensionExpr) {129	old := ctx.enterBlock()130	defer ctx.leaveBlock(old)131	formatForPhrases(ctx, v.Fors)132	formatExpr(ctx, v.Elt, &v.Elt)133}134func formatForPhrases(ctx *formatCtx, fors []*ast.ForPhrase) {135	for _, f := range fors {136		formatForPhrase(ctx, f)137	}138}139func formatForPhrase(ctx *formatCtx, v *ast.ForPhrase) {140	formatExpr(ctx, v.X, &v.X)141	formatStmt(ctx, v.Init)142	formatExpr(ctx, v.Cond, &v.Cond)143}144func formatSliceExpr(ctx *formatCtx, v *ast.SliceExpr) {145	formatExpr(ctx, v.X, &v.X)146	formatExpr(ctx, v.Low, &v.Low)147	formatExpr(ctx, v.High, &v.High)148	formatExpr(ctx, v.Max, &v.Max)149}150func formatCallExpr(ctx *formatCtx, v *ast.CallExpr) {151	formatExpr(ctx, v.Fun, &v.Fun)152	fncallStartingLowerCase(v)153	formatExprs(ctx, v.Args)154}155func formatSelectorExpr(ctx *formatCtx, v *ast.SelectorExpr, ref *ast.Expr) {156	switch x := v.X.(type) {157	case *ast.Ident:158		if _, o := ctx.scope.LookupParent(x.Name, token.NoPos); o != nil {159			break160		}161		if imp, ok := ctx.imports[x.Name]; ok {162			if !fmtToBuiltin(imp, v.Sel, ref) {163				imp.isUsed = true164			}165		}166	default:167		formatExpr(ctx, x, &v.X)168	}169}170// -----------------------------------------------------------------------------171func formatBlockStmt(ctx *formatCtx, stmt *ast.BlockStmt) {172	if stmt != nil {173		old := ctx.enterBlock()174		defer ctx.leaveBlock(old)175		formatStmts(ctx, stmt.List)176	}177}178func formatStmts(ctx *formatCtx, stmts []ast.Stmt) {179	for _, stmt := range stmts {180		formatStmt(ctx, stmt)181	}182}183func formatStmt(ctx *formatCtx, stmt ast.Stmt) {184	switch v := stmt.(type) {185	case *ast.ExprStmt:186		formatExprStmt(ctx, v)187	case *ast.AssignStmt:188		formatAssignStmt(ctx, v)189	case *ast.IncDecStmt:190		formatExpr(ctx, v.X, &v.X)191	case *ast.ForStmt:192		formatForStmt(ctx, v)193	case *ast.RangeStmt:194		formatRangeStmt(ctx, v)195	case *ast.ForPhraseStmt:196		formatForPhraseStmt(ctx, v)197	case *ast.IfStmt:198		formatIfStmt(ctx, v)199	case *ast.CaseClause:200		formatExprs(ctx, v.List)201		formatStmts(ctx, v.Body)202	case *ast.SwitchStmt:203		formatSwitchStmt(ctx, v)204	case *ast.TypeSwitchStmt:205		formatTypeSwitchStmt(ctx, v)206	case *ast.CommClause:207		formatStmt(ctx, v.Comm)208		formatStmts(ctx, v.Body)209	case *ast.SelectStmt:210		formatBlockStmt(ctx, v.Body)211	case *ast.DeclStmt:212		formatDeclStmt(ctx, v)213	case *ast.ReturnStmt:214		formatExprs(ctx, v.Results)215	case *ast.BlockStmt:216		formatBlockStmt(ctx, v)217	case *ast.DeferStmt:218		formatCallExpr(ctx, v.Call)219	case *ast.GoStmt:220		formatCallExpr(ctx, v.Call)221	case *ast.SendStmt:222		formatExpr(ctx, v.Chan, &v.Chan)223		formatExpr(ctx, v.Value, &v.Value)224	case *ast.LabeledStmt:225		formatStmt(ctx, v.Stmt)226	case *ast.BranchStmt, *ast.EmptyStmt, nil, *ast.BadStmt:227	default:228		log.Panicln("TODO: formatStmt -", reflect.TypeOf(stmt))229	}230}231func formatExprStmt(ctx *formatCtx, v *ast.ExprStmt) {232	switch x := v.X.(type) {233	case *ast.CallExpr:234		commandStyleFirst(x)235	}236	formatExpr(ctx, v.X, &v.X)237}238func formatAssignStmt(ctx *formatCtx, v *ast.AssignStmt) {239	formatExprs(ctx, v.Lhs)240	formatExprs(ctx, v.Rhs)241}242func formatSwitchStmt(ctx *formatCtx, v *ast.SwitchStmt) {243	old := ctx.enterBlock()244	defer ctx.leaveBlock(old)245	formatStmt(ctx, v.Init)246	formatExpr(ctx, v.Tag, &v.Tag)247	formatBlockStmt(ctx, v.Body)248}249func formatTypeSwitchStmt(ctx *formatCtx, v *ast.TypeSwitchStmt) {250	old := ctx.enterBlock()251	defer ctx.leaveBlock(old)252	formatStmt(ctx, v.Init)253	formatStmt(ctx, v.Assign)254	formatBlockStmt(ctx, v.Body)255}256func formatIfStmt(ctx *formatCtx, v *ast.IfStmt) {257	old := ctx.enterBlock()258	defer ctx.leaveBlock(old)259	formatStmt(ctx, v.Init)260	formatExpr(ctx, v.Cond, &v.Cond)261	formatBlockStmt(ctx, v.Body)262	formatStmt(ctx, v.Else)263}264func formatRangeStmt(ctx *formatCtx, v *ast.RangeStmt) {265	old := ctx.enterBlock()266	defer ctx.leaveBlock(old)267	formatExpr(ctx, v.Key, &v.Key)268	formatExpr(ctx, v.Value, &v.Value)269	formatExpr(ctx, v.X, &v.X)270	formatBlockStmt(ctx, v.Body)271}272func formatForPhraseStmt(ctx *formatCtx, v *ast.ForPhraseStmt) {273	old := ctx.enterBlock()274	defer ctx.leaveBlock(old)275	formatForPhrase(ctx, v.ForPhrase)276	formatBlockStmt(ctx, v.Body)277}278func formatForStmt(ctx *formatCtx, v *ast.ForStmt) {279	old := ctx.enterBlock()280	defer ctx.leaveBlock(old)281	formatStmt(ctx, v.Init)282	formatExpr(ctx, v.Cond, &v.Cond)283	formatBlockStmt(ctx, v.Body)284}285func formatDeclStmt(ctx *formatCtx, v *ast.DeclStmt) {286	if decl, ok := v.Decl.(*ast.GenDecl); ok {287		formatGenDecl(ctx, decl)288	}289}290// -----------------------------------------------------------------------------...

errors.go

Source:errors.go

1// Copyright 2012 The Go Authors. All rights reserved.2// Use of this source code is governed by a BSD-style3// license that can be found in the LICENSE file.4// This file implements various error reporters.5package types6import (7	"bytes"8	"fmt"9	"go/ast"10	"go/token"11)12// TODO(gri) eventually assert and unimplemented should disappear.13func assert(p bool) {14	if !p {15		panic("assertion failed")16	}17}18func unreachable() {19	panic("unreachable")20}21func (check *checker) printTrace(format string, args []interface{}) {22	const dots = ".  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  .  "23	n := len(check.pos) - 124	i := 3 * n25	for i > len(dots) {26		fmt.Print(dots)27		i -= len(dots)28	}29	// i <= len(dots)30	fmt.Printf("%s:\t", check.fset.Position(check.pos[n]))31	fmt.Print(dots[0:i])32	fmt.Println(check.formatMsg(format, args))33}34func (check *checker) trace(pos token.Pos, format string, args ...interface{}) {35	check.pos = append(check.pos, pos)36	check.printTrace(format, args)37}38func (check *checker) untrace(format string, args ...interface{}) {39	if len(format) > 0 {40		check.printTrace(format, args)41	}42	check.pos = check.pos[:len(check.pos)-1]43}44func (check *checker) formatMsg(format string, args []interface{}) string {45	for i, arg := range args {46		switch a := arg.(type) {47		case token.Pos:48			args[i] = check.fset.Position(a).String()49		case ast.Expr:50			args[i] = exprString(a)51		case Type:52			args[i] = typeString(a)53		case operand:54			panic("internal error: should always pass *operand")55		}56	}57	return fmt.Sprintf(format, args...)58}59// dump is only needed for debugging60func (check *checker) dump(format string, args ...interface{}) {61	fmt.Println(check.formatMsg(format, args))62}63func (check *checker) err(err error) {64	if check.firsterr == nil {65		check.firsterr = err66	}67	f := check.ctxt.Error68	if f == nil {69		panic(bailout{}) // report only first error70	}71	f(err)72}73func (check *checker) errorf(pos token.Pos, format string, args ...interface{}) {74	check.err(fmt.Errorf("%s: %s", check.fset.Position(pos), check.formatMsg(format, args)))75}76func (check *checker) invalidAST(pos token.Pos, format string, args ...interface{}) {77	check.errorf(pos, "invalid AST: "+format, args...)78}79func (check *checker) invalidArg(pos token.Pos, format string, args ...interface{}) {80	check.errorf(pos, "invalid argument: "+format, args...)81}82func (check *checker) invalidOp(pos token.Pos, format string, args ...interface{}) {83	check.errorf(pos, "invalid operation: "+format, args...)84}85// exprString returns a (simplified) string representation for an expression.86func exprString(expr ast.Expr) string {87	var buf bytes.Buffer88	writeExpr(&buf, expr)89	return buf.String()90}91// TODO(gri) Need to merge with typeString since some expressions are types (try: ([]int)(a))92func writeExpr(buf *bytes.Buffer, expr ast.Expr) {93	switch x := expr.(type) {94	case *ast.Ident:95		buf.WriteString(x.Name)96	case *ast.BasicLit:97		buf.WriteString(x.Value)98	case *ast.FuncLit:99		buf.WriteString("(func literal)")100	case *ast.CompositeLit:101		buf.WriteString("(composite literal)")102	case *ast.ParenExpr:103		buf.WriteByte('(')104		writeExpr(buf, x.X)105		buf.WriteByte(')')106	case *ast.SelectorExpr:107		writeExpr(buf, x.X)108		buf.WriteByte('.')109		buf.WriteString(x.Sel.Name)110	case *ast.IndexExpr:111		writeExpr(buf, x.X)112		buf.WriteByte('[')113		writeExpr(buf, x.Index)114		buf.WriteByte(']')115	case *ast.SliceExpr:116		writeExpr(buf, x.X)117		buf.WriteByte('[')118		if x.Low != nil {119			writeExpr(buf, x.Low)120		}121		buf.WriteByte(':')122		if x.High != nil {123			writeExpr(buf, x.High)124		}125		buf.WriteByte(']')126	case *ast.TypeAssertExpr:127		writeExpr(buf, x.X)128		buf.WriteString(".(...)")129	case *ast.CallExpr:130		writeExpr(buf, x.Fun)131		buf.WriteByte('(')132		for i, arg := range x.Args {133			if i > 0 {134				buf.WriteString(", ")135			}136			writeExpr(buf, arg)137		}138		buf.WriteByte(')')139	case *ast.StarExpr:140		buf.WriteByte('*')141		writeExpr(buf, x.X)142	case *ast.UnaryExpr:143		buf.WriteString(x.Op.String())144		writeExpr(buf, x.X)145	case *ast.BinaryExpr:146		// The AST preserves source-level parentheses so there is147		// no need to introduce parentheses here for correctness.148		writeExpr(buf, x.X)149		buf.WriteByte(' ')150		buf.WriteString(x.Op.String())151		buf.WriteByte(' ')152		writeExpr(buf, x.Y)153	default:154		fmt.Fprintf(buf, "<expr %T>", x)155	}156}157// typeString returns a string representation for typ.158func typeString(typ Type) string {159	var buf bytes.Buffer160	writeType(&buf, typ)161	return buf.String()162}163func writeParams(buf *bytes.Buffer, params []*Var, isVariadic bool) {164	buf.WriteByte('(')165	for i, par := range params {166		if i > 0 {167			buf.WriteString(", ")168		}169		if par.Name != "" {170			buf.WriteString(par.Name)171			buf.WriteByte(' ')172		}173		if isVariadic && i == len(params)-1 {174			buf.WriteString("...")175		}176		writeType(buf, par.Type)177	}178	buf.WriteByte(')')179}180func writeSignature(buf *bytes.Buffer, sig *Signature) {181	writeParams(buf, sig.Params, sig.IsVariadic)182	if len(sig.Results) == 0 {183		// no result184		return185	}186	buf.WriteByte(' ')187	if len(sig.Results) == 1 && sig.Results[0].Name == "" {188		// single unnamed result189		writeType(buf, sig.Results[0].Type.(Type))190		return191	}192	// multiple or named result(s)193	writeParams(buf, sig.Results, false)194}195func writeType(buf *bytes.Buffer, typ Type) {196	switch t := typ.(type) {197	case nil:198		buf.WriteString("<nil>")199	case *Basic:200		buf.WriteString(t.Name)201	case *Array:202		fmt.Fprintf(buf, "[%d]", t.Len)203		writeType(buf, t.Elt)204	case *Slice:205		buf.WriteString("[]")206		writeType(buf, t.Elt)207	case *Struct:208		buf.WriteString("struct{")209		for i, f := range t.Fields {210			if i > 0 {211				buf.WriteString("; ")212			}213			if !f.IsAnonymous {214				buf.WriteString(f.Name)215				buf.WriteByte(' ')216			}217			writeType(buf, f.Type)218			if f.Tag != "" {219				fmt.Fprintf(buf, " %q", f.Tag)220			}221		}222		buf.WriteByte('}')223	case *Pointer:224		buf.WriteByte('*')225		writeType(buf, t.Base)226	case *Result:227		writeParams(buf, t.Values, false)228	case *Signature:229		buf.WriteString("func")230		writeSignature(buf, t)231	case *builtin:232		fmt.Fprintf(buf, "<type of %s>", t.name)233	case *Interface:234		buf.WriteString("interface{")235		for i, m := range t.Methods {236			if i > 0 {237				buf.WriteString("; ")238			}239			buf.WriteString(m.Name)240			writeSignature(buf, m.Type)241		}242		buf.WriteByte('}')243	case *Map:244		buf.WriteString("map[")245		writeType(buf, t.Key)246		buf.WriteByte(']')247		writeType(buf, t.Elt)248	case *Chan:249		var s string250		switch t.Dir {251		case ast.SEND:252			s = "chan<- "253		case ast.RECV:254			s = "<-chan "255		default:256			s = "chan "257		}258		buf.WriteString(s)259		writeType(buf, t.Elt)260	case *NamedType:261		s := "<NamedType w/o object>"262		if obj := t.Obj; obj != nil {263			if obj.Pkg != nil && obj.Pkg.Path != "" {264				buf.WriteString(obj.Pkg.Path)265				buf.WriteString(".")266			}267			s = t.Obj.GetName()268		}269		buf.WriteString(s)270	default:271		fmt.Fprintf(buf, "<type %T>", t)272	}273}274func (t *Array) String() string     { return typeString(t) }275func (t *Basic) String() string     { return typeString(t) }276func (t *Chan) String() string      { return typeString(t) }277func (t *Interface) String() string { return typeString(t) }278func (t *Map) String() string       { return typeString(t) }279func (t *NamedType) String() string { return typeString(t) }280func (t *Pointer) String() string   { return typeString(t) }281func (t *Result) String() string    { return typeString(t) }282func (t *Signature) String() string { return typeString(t) }283func (t *Slice) String() string     { return typeString(t) }284func (t *Struct) String() string    { return typeString(t) }285func (t *builtin) String() string   { return typeString(t) }...

source.go

Source:source.go

...12	"strings"13	"github.com/pkg/errors"14)15const baseStackIndex = 116// FormattedCallExprArg returns the argument from an ast.CallExpr at the17// index in the call stack. The argument is formatted using FormatNode.18func FormattedCallExprArg(stackIndex int, argPos int) (string, error) {19	args, err := CallExprArgs(stackIndex + 1)20	if err != nil {21		return "", err22	}23	if argPos >= len(args) {24		return "", errors.New("failed to find expression")25	}26	return FormatNode(args[argPos])27}28// CallExprArgs returns the ast.Expr slice for the args of an ast.CallExpr at29// the index in the call stack.30func CallExprArgs(stackIndex int) ([]ast.Expr, error) {31	_, filename, lineNum, ok := runtime.Caller(baseStackIndex + stackIndex)32	if !ok {33		return nil, errors.New("failed to get call stack")34	}35	debug("call stack position: %s:%d", filename, lineNum)36	node, err := getNodeAtLine(filename, lineNum)37	if err != nil {38		return nil, err39	}40	debug("found node: %s", debugFormatNode{node})41	return getCallExprArgs(node)42}43func getNodeAtLine(filename string, lineNum int) (ast.Node, error) {44	fileset := token.NewFileSet()45	astFile, err := parser.ParseFile(fileset, filename, nil, parser.AllErrors)46	if err != nil {47		return nil, errors.Wrapf(err, "failed to parse source file: %s", filename)48	}49	if node := scanToLine(fileset, astFile, lineNum); node != nil {50		return node, nil51	}52	if node := scanToDeferLine(fileset, astFile, lineNum); node != nil {53		node, err := guessDefer(node)54		if err != nil || node != nil {55			return node, err56		}57	}58	return nil, errors.Errorf(59		"failed to find an expression on line %d in %s", lineNum, filename)60}61func scanToLine(fileset *token.FileSet, node ast.Node, lineNum int) ast.Node {62	var matchedNode ast.Node63	ast.Inspect(node, func(node ast.Node) bool {64		switch {65		case node == nil || matchedNode != nil:66			return false67		case nodePosition(fileset, node).Line == lineNum:68			matchedNode = node69			return false70		}71		return true72	})73	return matchedNode74}75// In golang 1.9 the line number changed from being the line where the statement76// ended to the line where the statement began.77func nodePosition(fileset *token.FileSet, node ast.Node) token.Position {78	if goVersionBefore19 {79		return fileset.Position(node.End())80	}81	return fileset.Position(node.Pos())82}83var goVersionBefore19 = func() bool {84	version := runtime.Version()85	// not a release version86	if !strings.HasPrefix(version, "go") {87		return false88	}89	version = strings.TrimPrefix(version, "go")90	parts := strings.Split(version, ".")91	if len(parts) < 2 {92		return false93	}94	minor, err := strconv.ParseInt(parts[1], 10, 32)95	return err == nil && parts[0] == "1" && minor < 996}()97func getCallExprArgs(node ast.Node) ([]ast.Expr, error) {98	visitor := &callExprVisitor{}99	ast.Walk(visitor, node)100	if visitor.expr == nil {101		return nil, errors.New("failed to find call expression")102	}103	debug("callExpr: %s", debugFormatNode{visitor.expr})104	return visitor.expr.Args, nil105}106type callExprVisitor struct {107	expr *ast.CallExpr108}109func (v *callExprVisitor) Visit(node ast.Node) ast.Visitor {110	if v.expr != nil || node == nil {111		return nil112	}113	debug("visit: %s", debugFormatNode{node})114	switch typed := node.(type) {115	case *ast.CallExpr:116		v.expr = typed117		return nil118	case *ast.DeferStmt:119		ast.Walk(v, typed.Call.Fun)120		return nil121	}122	return v123}124// FormatNode using go/format.Node and return the result as a string125func FormatNode(node ast.Node) (string, error) {126	buf := new(bytes.Buffer)127	err := format.Node(buf, token.NewFileSet(), node)128	return buf.String(), err129}130var debugEnabled = os.Getenv("GOTESTTOOLS_DEBUG") != ""131func debug(format string, args ...interface{}) {132	if debugEnabled {133		fmt.Fprintf(os.Stderr, "DEBUG: "+format+"\n", args...)134	}135}136type debugFormatNode struct {137	ast.Node138}139func (n debugFormatNode) String() string {140	out, err := FormatNode(n.Node)141	if err != nil {142		return fmt.Sprintf("failed to format %s: %s", n.Node, err)143	}144	return fmt.Sprintf("(%T) %s", n.Node, out)145}...

Format

Using AI Code Generation

1import (2func main() {3	import "fmt"4	func main() {5		fmt.Println("Hello, world!")6	}`7	f, err := parser.ParseFile(fset, "", src, 0)8	if err != nil {9		fmt.Println(err)10	}11	ast.Print(fset, f)12}13import (14func main() {15	import "fmt"16	func main() {17		fmt.Println("Hello, world!")18	}`19	f, err := parser.ParseFile(fset, "", src, 0)20	if err != nil {21		fmt.Println(err)22	}23	ast.Print(fset, f)24}25import (26func main() {27	import "fmt"28	func main() {29		fmt.Println("Hello, world!")30	}`31	f, err := parser.ParseFile(fset, "", src, 0)32	if err != nil {33		fmt.Println(err)34	}35	ast.Print(fset, f)36}37import (38func main() {39	import "fmt"40	func main() {41		fmt.Println("Hello, world!")42	}`43	f, err := parser.ParseFile(fset, "", src, 0)44	if err != nil {

Format

Using AI Code Generation

1import "fmt"2func main() {3    fmt.Printf("%s", "Hello World")4}5import "fmt"6func main() {7    fmt.Printf("%s", "Hello World")8}9import "fmt"10func main() {11    fmt.Printf("%s", "Hello World")12}13import "fmt"14func main() {15    fmt.Printf("%s", "Hello World")16}17import "fmt"18func main() {19    fmt.Printf("%s", "Hello World")20}21import "fmt"22func main() {23    fmt.Printf("%s", "Hello World")24}25import "fmt"26func main() {27    fmt.Printf("%s", "Hello World")28}29import "fmt"30func main() {31    fmt.Printf("%s", "Hello World")32}33import "fmt"34func main() {35    fmt.Printf("%s", "Hello World")36}37import "fmt"38func main() {39    fmt.Printf("%s", "Hello World")40}41import "fmt"42func main() {43    fmt.Printf("%s", "Hello World")44}45import "fmt"46func main() {47    fmt.Printf("%s", "Hello World")48}49import "fmt"50func main() {51    fmt.Printf("%s", "Hello World")52}53import "fmt"54func main() {55    fmt.Printf("%s", "Hello World")56}

Format

Using AI Code Generation

1import (2func main() {3	file := &ast.File{}4	funcDecl := &ast.FuncDecl{}5	ident := &ast.Ident{}6	file.Decls = append(file.Decls, funcDecl)7	fieldList := &ast.FieldList{}8	field := &ast.Field{}9	fieldList.List = append(fieldList.List, field)10	ident = &ast.Ident{}11	ident = &ast.Ident{}12	importSpec := &ast.ImportSpec{}13	importSpec.Path = ident14	genDecl := &ast.GenDecl{}15	genDecl.Specs = append(genDecl.Specs, importSpec)16	file.Imports = append(file.Imports, genDecl)17	blockStmt := &ast.BlockStmt{}18	exprStmt := &ast.ExprStmt{}19	blockStmt.List = append(blockStmt.List, exprStmt)

Format

Using AI Code Generation

1import (2func main() {3	node := ast.NewIdent("Ident")4	fmt.Println(node)5}6import (7func main() {8	node := ast.NewIdent("Ident")9	fmt.Println(node.Format(nil))10}11import (12func main() {13	node := ast.NewIdent("Ident")14	fmt.Println(node.Format(nil))15}16import (17func main() {18	node := ast.NewIdent("Ident")19	fmt.Println(node.Format(&ast.Comments{}))20}21import (22func main() {23	node := ast.NewIdent("Ident")24	fmt.Println(node.Format(&ast.Comments{List: []*ast.CommentGroup{}}))25}26import (27func main() {28	node := ast.NewIdent("Ident")29	fmt.Println(node.Format(&ast.Comments{List: []*ast.CommentGroup{&ast.CommentGroup{}}}))30}31import (32func main() {

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.