github.com/varialus/godfly@v0.0.0-20130904042352-1934f9f095ab/src/pkg/go/ast/example_test.go (about)

     1  // Copyright 2012 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package ast_test
     6  
     7  import (
     8  	"fmt"
     9  	"go/ast"
    10  	"go/parser"
    11  	"go/token"
    12  )
    13  
    14  // This example demonstrates how to inspect the AST of a Go program.
    15  func ExampleInspect() {
    16  	// src is the input for which we want to inspect the AST.
    17  	src := `
    18  package p
    19  const c = 1.0
    20  var X = f(3.14)*2 + c
    21  `
    22  
    23  	// Create the AST by parsing src.
    24  	fset := token.NewFileSet() // positions are relative to fset
    25  	f, err := parser.ParseFile(fset, "src.go", src, 0)
    26  	if err != nil {
    27  		panic(err)
    28  	}
    29  
    30  	// Inspect the AST and print all identifiers and literals.
    31  	ast.Inspect(f, func(n ast.Node) bool {
    32  		var s string
    33  		switch x := n.(type) {
    34  		case *ast.BasicLit:
    35  			s = x.Value
    36  		case *ast.Ident:
    37  			s = x.Name
    38  		}
    39  		if s != "" {
    40  			fmt.Printf("%s:\t%s\n", fset.Position(n.Pos()), s)
    41  		}
    42  		return true
    43  	})
    44  
    45  	// output:
    46  	// src.go:2:9:	p
    47  	// src.go:3:7:	c
    48  	// src.go:3:11:	1.0
    49  	// src.go:4:5:	X
    50  	// src.go:4:9:	f
    51  	// src.go:4:11:	3.14
    52  	// src.go:4:17:	2
    53  	// src.go:4:21:	c
    54  }
    55  
    56  // This example shows what an AST looks like when printed for debugging.
    57  func ExamplePrint() {
    58  	// src is the input for which we want to print the AST.
    59  	src := `
    60  package main
    61  func main() {
    62  	println("Hello, World!")
    63  }
    64  `
    65  
    66  	// Create the AST by parsing src.
    67  	fset := token.NewFileSet() // positions are relative to fset
    68  	f, err := parser.ParseFile(fset, "", src, 0)
    69  	if err != nil {
    70  		panic(err)
    71  	}
    72  
    73  	// Print the AST.
    74  	ast.Print(fset, f)
    75  
    76  	// output:
    77  	//      0  *ast.File {
    78  	//      1  .  Package: 2:1
    79  	//      2  .  Name: *ast.Ident {
    80  	//      3  .  .  NamePos: 2:9
    81  	//      4  .  .  Name: "main"
    82  	//      5  .  }
    83  	//      6  .  Decls: []ast.Decl (len = 1) {
    84  	//      7  .  .  0: *ast.FuncDecl {
    85  	//      8  .  .  .  Name: *ast.Ident {
    86  	//      9  .  .  .  .  NamePos: 3:6
    87  	//     10  .  .  .  .  Name: "main"
    88  	//     11  .  .  .  .  Obj: *ast.Object {
    89  	//     12  .  .  .  .  .  Kind: func
    90  	//     13  .  .  .  .  .  Name: "main"
    91  	//     14  .  .  .  .  .  Decl: *(obj @ 7)
    92  	//     15  .  .  .  .  }
    93  	//     16  .  .  .  }
    94  	//     17  .  .  .  Type: *ast.FuncType {
    95  	//     18  .  .  .  .  Func: 3:1
    96  	//     19  .  .  .  .  Params: *ast.FieldList {
    97  	//     20  .  .  .  .  .  Opening: 3:10
    98  	//     21  .  .  .  .  .  Closing: 3:11
    99  	//     22  .  .  .  .  }
   100  	//     23  .  .  .  }
   101  	//     24  .  .  .  Body: *ast.BlockStmt {
   102  	//     25  .  .  .  .  Lbrace: 3:13
   103  	//     26  .  .  .  .  List: []ast.Stmt (len = 1) {
   104  	//     27  .  .  .  .  .  0: *ast.ExprStmt {
   105  	//     28  .  .  .  .  .  .  X: *ast.CallExpr {
   106  	//     29  .  .  .  .  .  .  .  Fun: *ast.Ident {
   107  	//     30  .  .  .  .  .  .  .  .  NamePos: 4:2
   108  	//     31  .  .  .  .  .  .  .  .  Name: "println"
   109  	//     32  .  .  .  .  .  .  .  }
   110  	//     33  .  .  .  .  .  .  .  Lparen: 4:9
   111  	//     34  .  .  .  .  .  .  .  Args: []ast.Expr (len = 1) {
   112  	//     35  .  .  .  .  .  .  .  .  0: *ast.BasicLit {
   113  	//     36  .  .  .  .  .  .  .  .  .  ValuePos: 4:10
   114  	//     37  .  .  .  .  .  .  .  .  .  Kind: STRING
   115  	//     38  .  .  .  .  .  .  .  .  .  Value: "\"Hello, World!\""
   116  	//     39  .  .  .  .  .  .  .  .  }
   117  	//     40  .  .  .  .  .  .  .  }
   118  	//     41  .  .  .  .  .  .  .  Ellipsis: -
   119  	//     42  .  .  .  .  .  .  .  Rparen: 4:25
   120  	//     43  .  .  .  .  .  .  }
   121  	//     44  .  .  .  .  .  }
   122  	//     45  .  .  .  .  }
   123  	//     46  .  .  .  .  Rbrace: 5:1
   124  	//     47  .  .  .  }
   125  	//     48  .  .  }
   126  	//     49  .  }
   127  	//     50  .  Scope: *ast.Scope {
   128  	//     51  .  .  Objects: map[string]*ast.Object (len = 1) {
   129  	//     52  .  .  .  "main": *(obj @ 11)
   130  	//     53  .  .  }
   131  	//     54  .  }
   132  	//     55  .  Unresolved: []*ast.Ident (len = 1) {
   133  	//     56  .  .  0: *(obj @ 29)
   134  	//     57  .  }
   135  	//     58  }
   136  }