dst

type ArrayType ¶

type ArrayType struct {
	Len  Expr // Ellipsis node for [...]T array types, nil for slice types
	Elt  Expr // element type
	Decs ArrayTypeDecorations
}

An ArrayType node represents an array or slice type.

type ArrayTypeDecorations ¶

type ArrayTypeDecorations struct {
	Start       Decorations
	AfterLbrack Decorations
	AfterLen    Decorations
	End         Decorations
	Space       SpaceType
}

ArrayTypeDecorations holds decorations for ArrayType:

type R /*Start*/ [ /*AfterLbrack*/ 1] /*AfterLen*/ int /*End*/

type AssignStmt ¶

type AssignStmt struct {
	Lhs  []Expr
	Tok  token.Token // assignment token, DEFINE
	Rhs  []Expr
	Decs AssignStmtDecorations
}

An AssignStmt node represents an assignment or a short variable declaration.

type AssignStmtDecorations ¶

type AssignStmtDecorations struct {
	Start    Decorations
	AfterLhs Decorations
	AfterTok Decorations
	End      Decorations
	Space    SpaceType
}

AssignStmtDecorations holds decorations for AssignStmt:

/*Start*/
i /*AfterLhs*/ = /*AfterTok*/ 1 /*End*/

type BadDecl ¶

type BadDecl struct {
	Length int // position range of bad declaration
	Decs   BadDeclDecorations
}

A BadDecl node is a placeholder for declarations containing syntax errors for which no correct declaration nodes can be created.

type BadDeclDecorations ¶

type BadDeclDecorations struct {
	Space SpaceType
}

BadDeclDecorations holds decorations for BadDecl:

type BadExpr ¶

type BadExpr struct {
	Length int // position range of bad expression
	Decs   BadExprDecorations
}

A BadExpr node is a placeholder for expressions containing syntax errors for which no correct expression nodes can be created.

type BadExprDecorations ¶

type BadExprDecorations struct {
	Space SpaceType
}

BadExprDecorations holds decorations for BadExpr:

type BadStmt ¶

type BadStmt struct {
	Length int // position range of bad statement
	Decs   BadStmtDecorations
}

A BadStmt node is a placeholder for statements containing syntax errors for which no correct statement nodes can be created.

type BadStmtDecorations ¶

type BadStmtDecorations struct {
	Space SpaceType
}

BadStmtDecorations holds decorations for BadStmt:

type BasicLit ¶

type BasicLit struct {
	Kind  token.Token // token.INT, token.FLOAT, token.IMAG, token.CHAR, or token.STRING
	Value string      // literal string; e.g. 42, 0x7f, 3.14, 1e-9, 2.4i, 'a', '\x7f', "foo" or `\m\n\o`
	Decs  BasicLitDecorations
}

A BasicLit node represents a literal of basic type.

type BasicLitDecorations ¶

type BasicLitDecorations struct {
	Start Decorations
	End   Decorations
	Space SpaceType
}

BasicLitDecorations holds decorations for BasicLit:

type BinaryExpr ¶

type BinaryExpr struct {
	X    Expr        // left operand
	Op   token.Token // operator
	Y    Expr        // right operand
	Decs BinaryExprDecorations
}

A BinaryExpr node represents a binary expression.

type BinaryExprDecorations ¶

type BinaryExprDecorations struct {
	Start   Decorations
	AfterX  Decorations
	AfterOp Decorations
	End     Decorations
	Space   SpaceType
}

BinaryExprDecorations holds decorations for BinaryExpr:

var P = /*Start*/ 1 /*AfterX*/ & /*AfterOp*/ 2 /*End*/

type BlockStmt ¶

type BlockStmt struct {
	List []Stmt
	Decs BlockStmtDecorations
}

A BlockStmt node represents a braced statement list.

type BlockStmtDecorations ¶

type BlockStmtDecorations struct {
	Start       Decorations
	AfterLbrace Decorations
	End         Decorations
	Space       SpaceType
}

BlockStmtDecorations holds decorations for BlockStmt:

if true /*Start*/ { /*AfterLbrace*/
	i++
} /*End*/

func() /*Start*/ { /*AfterLbrace*/ i++ } /*End*/ ()

type BranchStmt ¶

type BranchStmt struct {
	Tok   token.Token // keyword token (BREAK, CONTINUE, GOTO, FALLTHROUGH)
	Label *Ident      // label name; or nil
	Decs  BranchStmtDecorations
}

A BranchStmt node represents a break, continue, goto, or fallthrough statement.

type BranchStmtDecorations ¶

type BranchStmtDecorations struct {
	Start    Decorations
	AfterTok Decorations
	End      Decorations
	Space    SpaceType
}

BranchStmtDecorations holds decorations for BranchStmt:

/*Start*/
goto /*AfterTok*/ A /*End*/

type CallExpr ¶

type CallExpr struct {
	Fun      Expr   // function expression
	Args     []Expr // function arguments; or nil
	Ellipsis bool
	Decs     CallExprDecorations
}

A CallExpr node represents an expression followed by an argument list.

type CallExprDecorations ¶

type CallExprDecorations struct {
	Start         Decorations
	AfterFun      Decorations
	AfterLparen   Decorations
	AfterArgs     Decorations
	AfterEllipsis Decorations
	End           Decorations
	Space         SpaceType
}

CallExprDecorations holds decorations for CallExpr:

var L = /*Start*/ C /*AfterFun*/ ( /*AfterLparen*/ 0, []int{} /*AfterArgs*/ ... /*AfterEllipsis*/) /*End*/

type CaseClause ¶

type CaseClause struct {
	List []Expr // list of expressions or types; nil means default case
	Body []Stmt // statement list; or nil
	Decs CaseClauseDecorations
}

A CaseClause represents a case of an expression or type switch statement.

type CaseClauseDecorations ¶

type CaseClauseDecorations struct {
	Start      Decorations
	AfterCase  Decorations
	AfterList  Decorations
	AfterColon Decorations
	Space      SpaceType
}

CaseClauseDecorations holds decorations for CaseClause:

switch i {
/*Start*/ case /*AfterCase*/ 1 /*AfterList*/ : /*AfterColon*/
	i++
}

type ChanDir ¶

type ChanDir int

The direction of a channel type is indicated by a bit mask including one or both of the following constants.

const (
	SEND ChanDir = 1 << iota
	RECV
)

type ChanType ¶

type ChanType struct {
	Dir   ChanDir // channel direction
	Value Expr    // value type
	Decs  ChanTypeDecorations
}

A ChanType node represents a channel type.

type ChanTypeDecorations ¶

type ChanTypeDecorations struct {
	Start      Decorations
	AfterBegin Decorations
	AfterArrow Decorations
	End        Decorations
	Space      SpaceType
}

ChanTypeDecorations holds decorations for ChanType:

type W /*Start*/ chan /*AfterBegin*/ int /*End*/

type X /*Start*/ <-chan /*AfterBegin*/ int /*End*/

type Y /*Start*/ chan /*AfterBegin*/ <- /*AfterArrow*/ int /*End*/

type CommClause ¶

type CommClause struct {
	Comm Stmt   // send or receive statement; nil means default case
	Body []Stmt // statement list; or nil
	Decs CommClauseDecorations
}

A CommClause node represents a case of a select statement.

type CommClauseDecorations ¶

type CommClauseDecorations struct {
	Start      Decorations
	AfterCase  Decorations
	AfterComm  Decorations
	AfterColon Decorations
	Space      SpaceType
}

CommClauseDecorations holds decorations for CommClause:

select {
/*Start*/ case /*AfterCase*/ a := <-c /*AfterComm*/ : /*AfterColon*/
	print(a)
}

type CompositeLit ¶

type CompositeLit struct {
	Type       Expr   // literal type; or nil
	Elts       []Expr // list of composite elements; or nil
	Incomplete bool   // true if (source) expressions are missing in the Elts list
	Decs       CompositeLitDecorations
}

A CompositeLit node represents a composite literal.

type CompositeLitDecorations ¶

type CompositeLitDecorations struct {
	Start       Decorations
	AfterType   Decorations
	AfterLbrace Decorations
	End         Decorations
	Space       SpaceType
}

CompositeLitDecorations holds decorations for CompositeLit:

var D = /*Start*/ A /*AfterType*/ { /*AfterLbrace*/ A: 0} /*End*/

type Decl ¶

type Decl interface {
	Node
	// contains filtered or unexported methods
}

All declaration nodes implement the Decl interface.

type DeclStmt ¶

type DeclStmt struct {
	Decl Decl // *GenDecl with CONST, TYPE, or VAR token
	Decs DeclStmtDecorations
}

A DeclStmt node represents a declaration in a statement list.

type DeclStmtDecorations ¶

type DeclStmtDecorations struct {
	Start Decorations
	End   Decorations
	Space SpaceType
}

DeclStmtDecorations holds decorations for DeclStmt:

type DecorationDecl ¶

type DecorationDecl struct {
	Decs DecorationDeclDecorations
}

DecorationDecl is for comments in a declaration list that are separated from other declarations by a blank line.

type DecorationDeclDecorations ¶

type DecorationDeclDecorations struct {
	Start Decorations
}

type DecorationStmt ¶

type DecorationStmt struct {
	Decs DecorationStmtDecorations
}

DecorationStmt is for comments in a statement list that are separated from other statements by a blank line.

type DecorationStmtDecorations ¶

type DecorationStmtDecorations struct {
	Start Decorations
}

type Decorations ¶

type Decorations []string

package main

import (
	"github.com/dave/dst"
	"github.com/dave/dst/decorator"
	"github.com/dave/dst/dstutil"
)

func main() {
	code := `package main

	func main() {
		var a int
		a++
		print(a)
	}`
	f, err := decorator.Parse(code)
	if err != nil {
		panic(err)
	}
	apply := func(c *dstutil.Cursor) bool {
		switch n := c.Node().(type) {
		case *dst.DeclStmt:
			n.Decs.End.Replace("// foo")
		case *dst.IncDecStmt:
			n.Decs.AfterX.Add("/* bar */")
		case *dst.CallExpr:
			n.Decs.AfterLparen.Add("\n")
			n.Decs.AfterArgs.Add("\n")
		}
		return true
	}
	f = dstutil.Apply(f, apply, nil).(*dst.File)
	if err := decorator.Print(f); err != nil {
		panic(err)
	}

}

Output:
package main

func main() {
	var a int // foo
	a /* bar */ ++
	print(
		a,
	)
}

func (d *Decorations) Add(decs ...string)

func (d *Decorations) Clear()

func (d *Decorations) Replace(decs ...string)

type DeferStmt ¶

type DeferStmt struct {
	Call *CallExpr
	Decs DeferStmtDecorations
}

A DeferStmt node represents a defer statement.

type DeferStmtDecorations ¶

type DeferStmtDecorations struct {
	Start      Decorations
	AfterDefer Decorations
	End        Decorations
	Space      SpaceType
}

DeferStmtDecorations holds decorations for DeferStmt:

/*Start*/
defer /*AfterDefer*/ func() {}() /*End*/

type Ellipsis ¶

type Ellipsis struct {
	Elt  Expr // ellipsis element type (parameter lists only); or nil
	Decs EllipsisDecorations
}

An Ellipsis node stands for the "..." type in a parameter list or the "..." length in an array type.

type EllipsisDecorations ¶

type EllipsisDecorations struct {
	Start         Decorations
	AfterEllipsis Decorations
	End           Decorations
	Space         SpaceType
}

EllipsisDecorations holds decorations for Ellipsis:

func B(a /*Start*/ ... /*AfterEllipsis*/ int /*End*/) {}

type EmptyStmt ¶

type EmptyStmt struct {
	Implicit bool // if set, ";" was omitted in the source
	Decs     EmptyStmtDecorations
}

An EmptyStmt node represents an empty statement. The "position" of the empty statement is the position of the immediately following (explicit or implicit) semicolon.

type EmptyStmtDecorations ¶

type EmptyStmtDecorations struct {
	Space SpaceType
}

EmptyStmtDecorations holds decorations for EmptyStmt:

type Expr ¶

type Expr interface {
	Node
	// contains filtered or unexported methods
}

All expression nodes implement the Expr interface.

type ExprStmt ¶

type ExprStmt struct {
	X    Expr // expression
	Decs ExprStmtDecorations
}

An ExprStmt node represents a (stand-alone) expression in a statement list.

type ExprStmtDecorations ¶

type ExprStmtDecorations struct {
	Start Decorations
	End   Decorations
	Space SpaceType
}

ExprStmtDecorations holds decorations for ExprStmt:

type Field ¶

type Field struct {
	Names []*Ident  // field/method/parameter names; or nil
	Type  Expr      // field/method/parameter type
	Tag   *BasicLit // field tag; or nil
	Decs  FieldDecorations
}

A Field represents a Field declaration list in a struct type, a method list in an interface type, or a parameter/result declaration in a signature. Field.Names is nil for unnamed parameters (parameter lists which only contain types) and embedded struct fields. In the latter case, the field name is the type name.

type FieldDecorations ¶

type FieldDecorations struct {
	Start      Decorations
	AfterNames Decorations
	AfterType  Decorations
	End        Decorations
	Space      SpaceType
}

FieldDecorations holds decorations for Field:

type A struct {
	/*Start*/ A /*AfterNames*/ int /*AfterType*/ `a:"a"` /*End*/
}

type FieldFilter ¶

type FieldFilter func(name string, value reflect.Value) bool

A FieldFilter may be provided to Fprint to control the output.

type FieldList ¶

type FieldList struct {
	Opening bool
	List    []*Field // field list; or nil
	Closing bool
	Decs    FieldListDecorations
}

A FieldList represents a list of Fields, enclosed by parentheses or braces.

func (f *FieldList) NumFields() int

type FieldListDecorations ¶

type FieldListDecorations struct {
	Start        Decorations
	AfterOpening Decorations
	End          Decorations
	Space        SpaceType
}

FieldListDecorations holds decorations for FieldList:

type A1 struct /*Start*/ { /*AfterOpening*/
	a, b int
	c    string
} /*End*/

type File ¶

type File struct {
	Name       *Ident        // package name
	Decls      []Decl        // top-level declarations; or nil
	Scope      *Scope        // package scope (this file only)
	Imports    []*ImportSpec // imports in this file
	Unresolved []*Ident      // unresolved identifiers in this file
	Decs       FileDecorations
}

A File node represents a Go source file.

The Comments list contains all comments in the source file in order of appearance, including the comments that are pointed to from other nodes via Doc and Comment fields.

For correct printing of source code containing comments (using packages go/format and go/printer), special care must be taken to update comments when a File's syntax tree is modified: For printing, comments are interspersed between tokens based on their position. If syntax tree nodes are removed or moved, relevant comments in their vicinity must also be removed (from the File.Comments list) or moved accordingly (by updating their positions). A CommentMap may be used to facilitate some of these operations.

Whether and how a comment is associated with a node depends on the interpretation of the syntax tree by the manipulating program: Except for Doc and Comment comments directly associated with nodes, the remaining comments are "free-floating" (see also issues #18593, #20744).

type FileDecorations ¶

type FileDecorations struct {
	Start        Decorations
	AfterPackage Decorations
	AfterName    Decorations
	Space        SpaceType
}

FileDecorations holds decorations for File:

/*Start*/ package /*AfterPackage*/ postests /*AfterName*/

type ForStmt ¶

type ForStmt struct {
	Init Stmt // initialization statement; or nil
	Cond Expr // condition; or nil
	Post Stmt // post iteration statement; or nil
	Body *BlockStmt
	Decs ForStmtDecorations
}

A ForStmt represents a for statement.

type ForStmtDecorations ¶

type ForStmtDecorations struct {
	Start     Decorations
	AfterFor  Decorations
	AfterInit Decorations
	AfterCond Decorations
	AfterPost Decorations
	End       Decorations
	Space     SpaceType
}

ForStmtDecorations holds decorations for ForStmt:

/*Start*/
for /*AfterFor*/ {
	i++
} /*End*/

/*Start*/
for /*AfterFor*/ i < 1 /*AfterCond*/ {
	i++
} /*End*/

/*Start*/
for /*AfterFor*/ i = 0; /*AfterInit*/ i < 10; /*AfterCond*/ i++ /*AfterPost*/ {
	i++
} /*End*/

type FuncDecl ¶

type FuncDecl struct {
	Recv *FieldList // receiver (methods); or nil (functions)
	Name *Ident     // function/method name
	Type *FuncType  // function signature: parameters, results, and position of "func" keyword
	Body *BlockStmt // function body; or nil for external (non-Go) function
	Decs FuncDeclDecorations
}

A FuncDecl node represents a function declaration.

type FuncDeclDecorations ¶

type FuncDeclDecorations struct {
	Start        Decorations
	AfterFunc    Decorations
	AfterRecv    Decorations
	AfterName    Decorations
	AfterParams  Decorations
	AfterResults Decorations
	End          Decorations
	Space        SpaceType
}

FuncDeclDecorations holds decorations for FuncDecl:

/*Start*/
func /*AfterFunc*/ d /*AfterName*/ (d, e int) /*AfterParams*/ {
	return
} /*End*/

/*Start*/
func /*AfterFunc*/ (a *A) /*AfterRecv*/ e /*AfterName*/ (d, e int) /*AfterParams*/ {
	return
} /*End*/

/*Start*/
func /*AfterFunc*/ (a *A) /*AfterRecv*/ f /*AfterName*/ (d, e int) /*AfterParams*/ (f, g int) /*AfterResults*/ {
	return
}

type FuncLit ¶

type FuncLit struct {
	Type *FuncType  // function type
	Body *BlockStmt // function body
	Decs FuncLitDecorations
}

A FuncLit node represents a function literal.

type FuncLitDecorations ¶

type FuncLitDecorations struct {
	Start     Decorations
	AfterType Decorations
	End       Decorations
	Space     SpaceType
}

FuncLitDecorations holds decorations for FuncLit:

var C = /*Start*/ func(a int, b ...int) (c int) /*AfterType*/ { return 0 } /*End*/

type FuncType ¶

type FuncType struct {
	Func    bool
	Params  *FieldList // (incoming) parameters; non-nil
	Results *FieldList // (outgoing) results; or nil
	Decs    FuncTypeDecorations
}

A FuncType node represents a function type.

type FuncTypeDecorations ¶

type FuncTypeDecorations struct {
	Start       Decorations
	AfterFunc   Decorations
	AfterParams Decorations
	End         Decorations
	Space       SpaceType
}

FuncTypeDecorations holds decorations for FuncType:

type T /*Start*/ func /*AfterFunc*/ (a int) /*AfterParams*/ (b int) /*End*/

type GenDecl ¶

type GenDecl struct {
	Tok    token.Token // IMPORT, CONST, TYPE, VAR
	Lparen bool
	Specs  []Spec
	Rparen bool
	Decs   GenDeclDecorations
}

A GenDecl node (generic declaration node) represents an import, constant, type or variable declaration. A valid Lparen position (Lparen.IsValid()) indicates a parenthesized declaration.

Relationship between Tok value and Specs element type:

token.IMPORT  *ImportSpec
token.CONST   *ValueSpec
token.TYPE    *TypeSpec
token.VAR     *ValueSpec

type GenDeclDecorations ¶

type GenDeclDecorations struct {
	Start       Decorations
	AfterTok    Decorations
	AfterLparen Decorations
	End         Decorations
	Space       SpaceType
}

GenDeclDecorations holds decorations for GenDecl:

/*Start*/
const /*AfterTok*/ ( /*AfterLparen*/
	a, b = 1, 2
	c    = 3
) /*End*/

/*Start*/
const /*AfterTok*/ d = 1 /*End*/

}

type GoStmt ¶

type GoStmt struct {
	Call *CallExpr
	Decs GoStmtDecorations
}

A GoStmt node represents a go statement.

type GoStmtDecorations ¶

type GoStmtDecorations struct {
	Start   Decorations
	AfterGo Decorations
	End     Decorations
	Space   SpaceType
}

GoStmtDecorations holds decorations for GoStmt:

/*Start*/
go /*AfterGo*/ func() {}() /*End*/

type Ident ¶

type Ident struct {
	Name string  // identifier name
	Obj  *Object // denoted object; or nil
	Decs IdentDecorations
}

An Ident node represents an identifier.

func NewIdent(name string) *Ident

func (id *Ident) IsExported() bool

func (id *Ident) String() string

type IdentDecorations ¶

type IdentDecorations struct {
	Start Decorations
	End   Decorations
	Space SpaceType
}

IdentDecorations holds decorations for Ident:

type IfStmt ¶

type IfStmt struct {
	Init Stmt // initialization statement; or nil
	Cond Expr // condition
	Body *BlockStmt
	Else Stmt // else branch; or nil
	Decs IfStmtDecorations
}

An IfStmt node represents an if statement.

type IfStmtDecorations ¶

type IfStmtDecorations struct {
	Start     Decorations
	AfterIf   Decorations
	AfterInit Decorations
	AfterCond Decorations
	AfterElse Decorations
	End       Decorations
	Space     SpaceType
}

IfStmtDecorations holds decorations for IfStmt:

/*Start*/
if /*AfterIf*/ a := b; /*AfterInit*/ a /*AfterCond*/ {
	i++
} else /*AfterElse*/ {
	i++
} /*End*/

type ImportSpec ¶

type ImportSpec struct {
	Name *Ident    // local package name (including "."); or nil
	Path *BasicLit // import path
	Decs ImportSpecDecorations
}

An ImportSpec node represents a single package import.

type ImportSpecDecorations ¶

type ImportSpecDecorations struct {
	Start     Decorations
	AfterName Decorations
	End       Decorations
	Space     SpaceType
}

ImportSpecDecorations holds decorations for ImportSpec:

import (
	/*Start*/ fmt /*AfterName*/ "fmt" /*End*/
)

type Importer ¶

type Importer func(imports map[string]*Object, path string) (pkg *Object, err error)

An Importer resolves import paths to package Objects. The imports map records the packages already imported, indexed by package id (canonical import path). An Importer must determine the canonical import path and check the map to see if it is already present in the imports map. If so, the Importer can return the map entry. Otherwise, the Importer should load the package data for the given path into a new *Object (pkg), record pkg in the imports map, and then return pkg.

type IncDecStmt ¶

type IncDecStmt struct {
	X    Expr
	Tok  token.Token // INC or DEC
	Decs IncDecStmtDecorations
}

An IncDecStmt node represents an increment or decrement statement.

type IncDecStmtDecorations ¶

type IncDecStmtDecorations struct {
	Start  Decorations
	AfterX Decorations
	End    Decorations
	Space  SpaceType
}

IncDecStmtDecorations holds decorations for IncDecStmt:

/*Start*/
i /*AfterX*/ ++ /*End*/

type IndexExpr ¶

type IndexExpr struct {
	X     Expr // expression
	Index Expr // index expression
	Decs  IndexExprDecorations
}

An IndexExpr node represents an expression followed by an index.

type IndexExprDecorations ¶

type IndexExprDecorations struct {
	Start       Decorations
	AfterX      Decorations
	AfterLbrack Decorations
	AfterIndex  Decorations
	End         Decorations
	Space       SpaceType
}

IndexExprDecorations holds decorations for IndexExpr:

var G = /*Start*/ []int{0} /*AfterX*/ [ /*AfterLbrack*/ 0 /*AfterIndex*/] /*End*/

type InterfaceType ¶

type InterfaceType struct {
	Methods    *FieldList // list of methods
	Incomplete bool       // true if (source) methods are missing in the Methods list
	Decs       InterfaceTypeDecorations
}

An InterfaceType node represents an interface type.

type InterfaceTypeDecorations ¶

type InterfaceTypeDecorations struct {
	Start          Decorations
	AfterInterface Decorations
	End            Decorations
	Space          SpaceType
}

InterfaceTypeDecorations holds decorations for InterfaceType:

type U /*Start*/ interface /*AfterInterface*/ {
	A()
} /*End*/

type KeyValueExpr ¶

type KeyValueExpr struct {
	Key   Expr
	Value Expr
	Decs  KeyValueExprDecorations
}

A KeyValueExpr node represents (key : value) pairs in composite literals.

type KeyValueExprDecorations ¶

type KeyValueExprDecorations struct {
	Start      Decorations
	AfterKey   Decorations
	AfterColon Decorations
	End        Decorations
	Space      SpaceType
}

KeyValueExprDecorations holds decorations for KeyValueExpr:

var Q = map[string]string{
	/*Start*/ "a" /*AfterKey*/ : /*AfterColon*/ "a", /*End*/
}

type LabeledStmt ¶

type LabeledStmt struct {
	Label *Ident
	Stmt  Stmt
	Decs  LabeledStmtDecorations
}

A LabeledStmt node represents a labeled statement.

type LabeledStmtDecorations ¶

type LabeledStmtDecorations struct {
	Start      Decorations
	AfterLabel Decorations
	AfterColon Decorations
	End        Decorations
	Space      SpaceType
}

LabeledStmtDecorations holds decorations for LabeledStmt:

/*Start*/
A /*AfterLabel*/ : /*AfterColon*/
	print("Stmt") /*End*/

type MapType ¶

type MapType struct {
	Key   Expr
	Value Expr
	Decs  MapTypeDecorations
}

A MapType node represents a map type.

type MapTypeDecorations ¶

type MapTypeDecorations struct {
	Start    Decorations
	AfterMap Decorations
	AfterKey Decorations
	End      Decorations
	Space    SpaceType
}

MapTypeDecorations holds decorations for MapType:

type V /*Start*/ map[ /*AfterMap*/ int] /*AfterKey*/ int /*End*/

type Node ¶

type Node interface {
	// contains filtered or unexported methods
}

All node types implement the Node interface.

type ObjKind ¶

type ObjKind int

ObjKind describes what an object represents.

const (
	Bad ObjKind = iota // for error handling
	Pkg                // package
	Con                // constant
	Typ                // type
	Var                // variable
	Fun                // function or method
	Lbl                // label
)

func (kind ObjKind) String() string

type Object ¶

type Object struct {
	Kind ObjKind
	Name string      // declared name
	Decl interface{} // corresponding Field, XxxSpec, FuncDecl, LabeledStmt, AssignStmt, Scope; or nil
	Data interface{} // object-specific data; or nil
	Type interface{} // placeholder for type information; may be nil
}

An Object describes a named language entity such as a package, constant, type, variable, function (incl. methods), or label.

The Data fields contains object-specific data:

Kind    Data type         Data value
Pkg     *Scope            package scope
Con     int               iota for the respective declaration

func NewObj(kind ObjKind, name string) *Object

type Package ¶

type Package struct {
	Name    string             // package name
	Scope   *Scope             // package scope across all files
	Imports map[string]*Object // map of package id -> package object
	Files   map[string]*File   // Go source files by filename
}

A Package node represents a set of source files collectively building a Go package.

func NewPackage(fset *token.FileSet, files map[string]*File, importer Importer, universe *Scope) (*Package, error)

type PackageDecorations ¶ added in v0.1.0

type PackageDecorations struct {
	Space SpaceType
}

PackageDecorations holds decorations for Package:

type ParenExpr ¶

type ParenExpr struct {
	X    Expr // parenthesized expression
	Decs ParenExprDecorations
}

A ParenExpr node represents a parenthesized expression.

type ParenExprDecorations ¶

type ParenExprDecorations struct {
	Start       Decorations
	AfterLparen Decorations
	AfterX      Decorations
	End         Decorations
	Space       SpaceType
}

ParenExprDecorations holds decorations for ParenExpr:

var E = /*Start*/ ( /*AfterLparen*/ 1 + 1 /*AfterX*/) /*End*/ / 2

type RangeStmt ¶

type RangeStmt struct {
	Key, Value Expr        // Key, Value may be nil
	Tok        token.Token // ILLEGAL if Key == nil, ASSIGN, DEFINE
	X          Expr        // value to range over
	Body       *BlockStmt
	Decs       RangeStmtDecorations
}

A RangeStmt represents a for statement with a range clause.

type RangeStmtDecorations ¶

type RangeStmtDecorations struct {
	Start      Decorations
	AfterFor   Decorations
	AfterKey   Decorations
	AfterValue Decorations
	AfterRange Decorations
	AfterX     Decorations
	End        Decorations
	Space      SpaceType
}

RangeStmtDecorations holds decorations for RangeStmt:

/*Start*/
for range /*AfterRange*/ a /*AfterX*/ {
} /*End*/

/*Start*/
for /*AfterFor*/ k /*AfterKey*/ := range /*AfterRange*/ a /*AfterX*/ {
	print(k)
} /*End*/

/*Start*/
for /*AfterFor*/ k /*AfterKey*/, v /*AfterValue*/ := range /*AfterRange*/ a /*AfterX*/ {
	print(k, v)
} /*End*/

type ReturnStmt ¶

type ReturnStmt struct {
	Results []Expr // result expressions; or nil
	Decs    ReturnStmtDecorations
}

A ReturnStmt node represents a return statement.

type ReturnStmtDecorations ¶

type ReturnStmtDecorations struct {
	Start       Decorations
	AfterReturn Decorations
	End         Decorations
	Space       SpaceType
}

ReturnStmtDecorations holds decorations for ReturnStmt:

func() int {
	/*Start*/ return /*AfterReturn*/ 1 /*End*/
}()

type Scope ¶

type Scope struct {
	Outer   *Scope
	Objects map[string]*Object
}

A Scope maintains the set of named language entities declared in the scope and a link to the immediately surrounding (outer) scope.

func NewScope(outer *Scope) *Scope

func (s *Scope) Insert(obj *Object) (alt *Object)

func (s *Scope) Lookup(name string) *Object

func (s *Scope) String() string

type SelectStmt ¶

type SelectStmt struct {
	Body *BlockStmt // CommClauses only
	Decs SelectStmtDecorations
}

An SelectStmt node represents a select statement.

type SelectStmtDecorations ¶

type SelectStmtDecorations struct {
	Start       Decorations
	AfterSelect Decorations
	End         Decorations
	Space       SpaceType
}

SelectStmtDecorations holds decorations for SelectStmt:

/*Start*/
select /*AfterSelect*/ {
} /*End*/

type SelectorExpr ¶

type SelectorExpr struct {
	X    Expr   // expression
	Sel  *Ident // field selector
	Decs SelectorExprDecorations
}

A SelectorExpr node represents an expression followed by a selector.

type SelectorExprDecorations ¶

type SelectorExprDecorations struct {
	Start  Decorations
	AfterX Decorations
	End    Decorations
	Space  SpaceType
}

SelectorExprDecorations holds decorations for SelectorExpr:

var F = /*Start*/ fmt. /*AfterX*/ Sprint /*End*/ (0)

type SendStmt ¶

type SendStmt struct {
	Chan  Expr
	Value Expr
	Decs  SendStmtDecorations
}

A SendStmt node represents a send statement.

type SendStmtDecorations ¶

type SendStmtDecorations struct {
	Start      Decorations
	AfterChan  Decorations
	AfterArrow Decorations
	End        Decorations
	Space      SpaceType
}

SendStmtDecorations holds decorations for SendStmt:

/*Start*/
c /*AfterChan*/ <- /*AfterArrow*/ 0 /*End*/

type SliceExpr ¶

type SliceExpr struct {
	X      Expr // expression
	Low    Expr // begin of slice range; or nil
	High   Expr // end of slice range; or nil
	Max    Expr // maximum capacity of slice; or nil
	Slice3 bool // true if 3-index slice (2 colons present)
	Decs   SliceExprDecorations
}

An SliceExpr node represents an expression followed by slice indices.

type SliceExprDecorations ¶

type SliceExprDecorations struct {
	Start       Decorations
	AfterX      Decorations
	AfterLbrack Decorations
	AfterLow    Decorations
	AfterHigh   Decorations
	AfterMax    Decorations
	End         Decorations
	Space       SpaceType
}

SliceExprDecorations holds decorations for SliceExpr:

var H = /*Start*/ []int{0} /*AfterX*/ [ /*AfterLbrack*/ 1: /*AfterLow*/ 2: /*AfterHigh*/ 3 /*AfterMax*/] /*End*/

var H1 = /*Start*/ []int{0} /*AfterX*/ [ /*AfterLbrack*/ 1: /*AfterLow*/ 2 /*AfterHigh*/] /*End*/

var H2 = /*Start*/ []int{0} /*AfterX*/ [: /*AfterLow*/] /*End*/

var H3 = /*Start*/ []int{0} /*AfterX*/ [ /*AfterLbrack*/ 1: /*AfterLow*/] /*End*/

var H4 = /*Start*/ []int{0} /*AfterX*/ [: /*AfterLow*/ 2 /*AfterHigh*/] /*End*/

var H5 = /*Start*/ []int{0} /*AfterX*/ [: /*AfterLow*/ 2: /*AfterHigh*/ 3 /*AfterMax*/] /*End*/

type SpaceType ¶ added in v0.1.0

type SpaceType int

const (
	None      SpaceType = 0
	NewLine   SpaceType = 1
	EmptyLine SpaceType = 2
)

type Spec ¶

type Spec interface {
	Node
	// contains filtered or unexported methods
}

The Spec type stands for any of *ImportSpec, *ValueSpec, and *TypeSpec.

type StarExpr ¶

type StarExpr struct {
	X    Expr // operand
	Decs StarExprDecorations
}

A StarExpr node represents an expression of the form "*" Expression. Semantically it could be a unary "*" expression, or a pointer type.

type StarExprDecorations ¶

type StarExprDecorations struct {
	Start     Decorations
	AfterStar Decorations
	End       Decorations
	Space     SpaceType
}

StarExprDecorations holds decorations for StarExpr:

var N = /*Start*/ * /*AfterStar*/ p /*End*/

type Stmt ¶

type Stmt interface {
	Node
	// contains filtered or unexported methods
}

All statement nodes implement the Stmt interface.

type StructType ¶

type StructType struct {
	Fields     *FieldList // list of field declarations
	Incomplete bool       // true if (source) fields are missing in the Fields list
	Decs       StructTypeDecorations
}

A StructType node represents a struct type.

type StructTypeDecorations ¶

type StructTypeDecorations struct {
	Start       Decorations
	AfterStruct Decorations
	End         Decorations
	Space       SpaceType
}

StructTypeDecorations holds decorations for StructType:

type S /*Start*/ struct /*AfterStruct*/ {
	A int
} /*End*/

type SwitchStmt ¶

type SwitchStmt struct {
	Init Stmt       // initialization statement; or nil
	Tag  Expr       // tag expression; or nil
	Body *BlockStmt // CaseClauses only
	Decs SwitchStmtDecorations
}

A SwitchStmt node represents an expression switch statement.

type SwitchStmtDecorations ¶

type SwitchStmtDecorations struct {
	Start       Decorations
	AfterSwitch Decorations
	AfterInit   Decorations
	AfterTag    Decorations
	End         Decorations
	Space       SpaceType
}

SwitchStmtDecorations holds decorations for SwitchStmt:

/*Start*/
switch /*AfterSwitch*/ i /*AfterTag*/ {
} /*End*/

/*Start*/
switch /*AfterSwitch*/ a := i; /*AfterInit*/ a /*AfterTag*/ {
} /*End*/

type TypeAssertExpr ¶

type TypeAssertExpr struct {
	X    Expr // expression
	Type Expr // asserted type; nil means type switch X.(type)
	Decs TypeAssertExprDecorations
}

A TypeAssertExpr node represents an expression followed by a type assertion.

type TypeAssertExprDecorations ¶

type TypeAssertExprDecorations struct {
	Start       Decorations
	AfterX      Decorations
	AfterLparen Decorations
	AfterType   Decorations
	End         Decorations
	Space       SpaceType
}

TypeAssertExprDecorations holds decorations for TypeAssertExpr:

var J = /*Start*/ f. /*AfterX*/ ( /*AfterLparen*/ int /*AfterType*/) /*End*/

type TypeSpec ¶

type TypeSpec struct {
	Name   *Ident // type name
	Assign bool   // position of '=', if any
	Type   Expr   // *Ident, *ParenExpr, *SelectorExpr, *StarExpr, or any of the *XxxTypes
	Decs   TypeSpecDecorations
}

A TypeSpec node represents a type declaration (TypeSpec production).

type TypeSpecDecorations ¶

type TypeSpecDecorations struct {
	Start     Decorations
	AfterName Decorations
	End       Decorations
	Space     SpaceType
}

TypeSpecDecorations holds decorations for TypeSpec:

type (
	/*Start*/ T1 /*AfterName*/ []int /*End*/
)

type (
	/*Start*/ T2 = /*AfterName*/ T1 /*End*/
)

type TypeSwitchStmt ¶

type TypeSwitchStmt struct {
	Init   Stmt       // initialization statement; or nil
	Assign Stmt       // x := y.(type) or y.(type)
	Body   *BlockStmt // CaseClauses only
	Decs   TypeSwitchStmtDecorations
}

An TypeSwitchStmt node represents a type switch statement.

type TypeSwitchStmtDecorations ¶

type TypeSwitchStmtDecorations struct {
	Start       Decorations
	AfterSwitch Decorations
	AfterInit   Decorations
	AfterAssign Decorations
	End         Decorations
	Space       SpaceType
}

TypeSwitchStmtDecorations holds decorations for TypeSwitchStmt:

/*Start*/
switch /*AfterSwitch*/ f.(type) /*AfterAssign*/ {
} /*End*/

/*Start*/
switch /*AfterSwitch*/ g := f.(type) /*AfterAssign*/ {
case int:
	print(g)
} /*End*/

/*Start*/
switch /*AfterSwitch*/ g := f; /*AfterInit*/ g := g.(type) /*AfterAssign*/ {
case int:
	print(g)
} /*End*/

type UnaryExpr ¶

type UnaryExpr struct {
	Op   token.Token // operator
	X    Expr        // operand
	Decs UnaryExprDecorations
}

A UnaryExpr node represents a unary expression. Unary "*" expressions are represented via StarExpr nodes.

type UnaryExprDecorations ¶

type UnaryExprDecorations struct {
	Start   Decorations
	AfterOp Decorations
	End     Decorations
	Space   SpaceType
}

UnaryExprDecorations holds decorations for UnaryExpr:

var O = /*Start*/ ^ /*AfterOp*/ 1 /*End*/

type ValueSpec ¶

type ValueSpec struct {
	Names  []*Ident // value names (len(Names) > 0)
	Type   Expr     // value type; or nil
	Values []Expr   // initial values; or nil
	Decs   ValueSpecDecorations
}

A ValueSpec node represents a constant or variable declaration (ConstSpec or VarSpec production).

type ValueSpecDecorations ¶

type ValueSpecDecorations struct {
	Start       Decorations
	AfterNames  Decorations
	AfterAssign Decorations
	End         Decorations
	Space       SpaceType
}

ValueSpecDecorations holds decorations for ValueSpec:

var (
	/*Start*/ j = /*AfterAssign*/ 1 /*End*/
)

var (
	/*Start*/ k, l = /*AfterAssign*/ 1, 2 /*End*/
)

var (
	/*Start*/ m, n /*AfterNames*/ int = /*AfterAssign*/ 1, 2 /*End*/
)

type Visitor ¶

type Visitor interface {
	Visit(node Node) (w Visitor)
}

A Visitor's Visit method is invoked for each node encountered by Walk. If the result visitor w is not nil, Walk visits each of the children of node with the visitor w, followed by a call of w.Visit(nil).