js

package
v2.5.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 29, 2020 License: MIT Imports: 8 Imported by: 29

README

JS GoDoc

This package is a JS lexer (ECMAScript 2020) written in Go. It follows the specification at ECMAScript 2020 Language Specification. The lexer takes an io.Reader and converts it into tokens until the EOF.

Installation

Run the following command

go get -u github.com/tdewolff/parse/v2/js

or add the following import and run project with go get

import "github.com/tdewolff/parse/v2/js"

Lexer

Usage

The following initializes a new Lexer with io.Reader r:

l := js.NewLexer(r)

To tokenize until EOF an error, use:

for {
	tt, text := l.Next()
	switch tt {
	case js.ErrorToken:
		// error or EOF set in l.Err()
		return
	// ...
	}
}
Regular Expressions

The ECMAScript specification for PunctuatorToken (of which the / and /= symbols) and RegExpToken depend on a parser state to differentiate between the two. The lexer will always parse the first token as / or /= operator, upon which the parser can rescan that token to scan a regular expression using RegExp().

Examples
package main

import (
	"os"

	"github.com/tdewolff/parse/v2/js"
)

// Tokenize JS from stdin.
func main() {
	l := js.NewLexer(os.Stdin)
	for {
		tt, text := l.Next()
		switch tt {
		case js.ErrorToken:
			if l.Err() != io.EOF {
				fmt.Println("Error on line", l.Line(), ":", l.Err())
			}
			return
		case js.IdentifierToken:
			fmt.Println("Identifier", string(text))
		case js.NumericToken:
			fmt.Println("Numeric", string(text))
		// ...
		}
	}
}

License

Released under the MIT license.

Documentation

Overview

Package js is an ECMAScript5.1 lexer following the specifications at http://www.ecma-international.org/ecma-262/5.1/.

Index

Examples

Constants

This section is empty.

Variables

View Source 
var Keywords = map[string]TokenType{

	"await":      AwaitToken,
	"break":      BreakToken,
	"case":       CaseToken,
	"catch":      CatchToken,
	"class":      ClassToken,
	"const":      ConstToken,
	"continue":   ContinueToken,
	"debugger":   DebuggerToken,
	"default":    DefaultToken,
	"delete":     DeleteToken,
	"do":         DoToken,
	"else":       ElseToken,
	"enum":       EnumToken,
	"export":     ExportToken,
	"extends":    ExtendsToken,
	"false":      FalseToken,
	"finally":    FinallyToken,
	"for":        ForToken,
	"function":   FunctionToken,
	"if":         IfToken,
	"import":     ImportToken,
	"in":         InToken,
	"instanceof": InstanceofToken,
	"new":        NewToken,
	"null":       NullToken,
	"return":     ReturnToken,
	"super":      SuperToken,
	"switch":     SwitchToken,
	"this":       ThisToken,
	"throw":      ThrowToken,
	"true":       TrueToken,
	"try":        TryToken,
	"typeof":     TypeofToken,
	"var":        VarToken,
	"void":       VoidToken,
	"while":      WhileToken,
	"with":       WithToken,
	"yield":      YieldToken,

	"let":        LetToken,
	"static":     StaticToken,
	"implements": ImplementsToken,
	"interface":  InterfaceToken,
	"package":    PackageToken,
	"private":    PrivateToken,
	"protected":  ProtectedToken,
	"public":     PublicToken,

	"as":     AsToken,
	"async":  AsyncToken,
	"from":   FromToken,
	"get":    GetToken,
	"meta":   MetaToken,
	"of":     OfToken,
	"set":    SetToken,
	"target": TargetToken,
}

Functions

func AsDecimalLiteral added in v2.5.0 

func AsDecimalLiteral(b []byte) bool

func AsIdentifierName added in v2.5.0 

func AsIdentifierName(b []byte) bool

func IsIdentifier added in v2.5.0 

func IsIdentifier(tt TokenType) bool

IsIdentifier matches Identifier, i.e. IdentifierName but not ReservedWord. Does not match yield or await.

func IsIdentifierContinue added in v2.5.0 

func IsIdentifierContinue(b []byte) bool

IsIdentifierContinue returns true if the byte-slice start is a continuation of an identifier

func IsIdentifierEnd added in v2.5.0 

func IsIdentifierEnd(b []byte) bool

IsIdentifierEnd returns true if the byte-slice end is a start or continuation of an identifier

func IsIdentifierName added in v2.5.0 

func IsIdentifierName(tt TokenType) bool

IsIdentifierName matches IdentifierName, i.e. any identifier

func IsIdentifierStart added in v2.5.0 

func IsIdentifierStart(b []byte) bool

IsIdentifierStart returns true if the byte-slice start is the start of an identifier

func IsNumeric added in v2.5.0 

func IsNumeric(tt TokenType) bool

func IsOperator added in v2.5.0 

func IsOperator(tt TokenType) bool

func IsPunctuator added in v2.5.0 

func IsPunctuator(tt TokenType) bool

func IsReservedWord added in v2.5.0 

func IsReservedWord(tt TokenType) bool

IsReservedWord matches ReservedWord

Types

type AST added in v2.5.0 

type AST struct {
	Comments  [][]byte // first comments in file
	BlockStmt          // module
}

func Parse added in v2.5.0 

func Parse(r *parse.Input) (*AST, error)

Parse returns a JS AST tree of.

func (*AST) String added in v2.5.0 

func (ast *AST) String() string

type Alias added in v2.5.0 

type Alias struct {
	Name    []byte // can be nil
	Binding []byte // can be nil
}

func (Alias) String added in v2.5.0 

func (alias Alias) String() string

type Arguments added in v2.5.0 

type Arguments struct {
	List []IExpr
	Rest IExpr // can be nil
}

func (Arguments) String added in v2.5.0 

func (n Arguments) String() string

type ArrayExpr added in v2.5.0 

type ArrayExpr struct {
	List []Element
}

func (ArrayExpr) String added in v2.5.0 

func (n ArrayExpr) String() string

type ArrowFunc added in v2.5.0 

type ArrowFunc struct {
	Async  bool
	Params Params
	Body   BlockStmt
}

func (ArrowFunc) String added in v2.5.0 

func (n ArrowFunc) String() string

type BinaryExpr added in v2.5.0 

type BinaryExpr struct {
	Op   TokenType
	X, Y IExpr
}

func (BinaryExpr) String added in v2.5.0 

func (n BinaryExpr) String() string

type BindingArray added in v2.5.0 

type BindingArray struct {
	List []BindingElement
	Rest IBinding // can be nil
}

func (BindingArray) String added in v2.5.0 

func (n BindingArray) String() string

type BindingElement added in v2.5.0 

type BindingElement struct {
	Binding IBinding // can be nil (in case of ellision)
	Default IExpr    // can be nil
}

func (BindingElement) String added in v2.5.0 

func (n BindingElement) String() string

type BindingObject added in v2.5.0 

type BindingObject struct {
	List []BindingObjectItem
	Rest *Var // can be nil
}

func (BindingObject) String added in v2.5.0 

func (n BindingObject) String() string

type BindingObjectItem added in v2.5.0 

type BindingObjectItem struct {
	Key   *PropertyName // can be nil
	Value BindingElement
}

type BlockStmt added in v2.5.0 

type BlockStmt struct {
	List []IStmt
	Scope
}

func (BlockStmt) String added in v2.5.0 

func (n BlockStmt) String() string

type BranchStmt added in v2.5.0 

type BranchStmt struct {
	Type  TokenType
	Label []byte // can be nil
}

func (BranchStmt) String added in v2.5.0 

func (n BranchStmt) String() string

type CallExpr added in v2.5.0 

type CallExpr struct {
	X    IExpr
	Args Arguments
}

func (CallExpr) String added in v2.5.0 

func (n CallExpr) String() string

type CaseClause added in v2.5.0 

type CaseClause struct {
	TokenType
	Cond IExpr // can be nil
	List []IStmt
}

type ClassDecl added in v2.5.0 

type ClassDecl struct {
	Name    *Var  // can be nil
	Extends IExpr // can be nil
	Methods []MethodDecl
}

func (ClassDecl) String added in v2.5.0 

func (n ClassDecl) String() string

type CondExpr added in v2.5.0 

type CondExpr struct {
	Cond, X, Y IExpr
}

func (CondExpr) String added in v2.5.0 

func (n CondExpr) String() string

type DebuggerStmt added in v2.5.0 

type DebuggerStmt struct {
}

func (DebuggerStmt) String added in v2.5.0 

func (n DebuggerStmt) String() string

type DeclType added in v2.5.0 

type DeclType uint16
const (
	NoDecl       DeclType = iota // undeclared variables
	VariableDecl                 // var
	FunctionDecl                 // function
	LexicalDecl                  // let, const, class
	ArgumentDecl                 // function, method, and catch statement arguments
	ExprDecl                     // function expression name or class expression name
)

func (DeclType) String added in v2.5.0 

func (decl DeclType) String() string

type DoWhileStmt added in v2.5.0 

type DoWhileStmt struct {
	Cond IExpr
	Body IStmt
}

func (DoWhileStmt) String added in v2.5.0 

func (n DoWhileStmt) String() string

type DotExpr added in v2.5.0 

type DotExpr struct {
	X    IExpr
	Y    LiteralExpr
	Prec OpPrec
}

func (DotExpr) String added in v2.5.0 

func (n DotExpr) String() string

type Element added in v2.5.0 

type Element struct {
	Value  IExpr // can be nil
	Spread bool
}

type EmptyStmt added in v2.5.0 

type EmptyStmt struct {
}

func (EmptyStmt) String added in v2.5.0 

func (n EmptyStmt) String() string

type ExportStmt added in v2.5.0 

type ExportStmt struct {
	List    []Alias
	Module  []byte // can be nil
	Default bool
	Decl    IExpr
}

func (ExportStmt) String added in v2.5.0 

func (n ExportStmt) String() string

type ExprStmt added in v2.5.0 

type ExprStmt struct {
	Value IExpr
}

func (ExprStmt) String added in v2.5.0 

func (n ExprStmt) String() string

type ForInStmt added in v2.5.0 

type ForInStmt struct {
	Init  IExpr
	Value IExpr
	Body  BlockStmt
}

func (ForInStmt) String added in v2.5.0 

func (n ForInStmt) String() string

type ForOfStmt added in v2.5.0 

type ForOfStmt struct {
	Await bool
	Init  IExpr
	Value IExpr
	Body  BlockStmt
}

func (ForOfStmt) String added in v2.5.0 

func (n ForOfStmt) String() string

type ForStmt added in v2.5.0 

type ForStmt struct {
	Init IExpr // can be nil
	Cond IExpr // can be nil
	Post IExpr // can be nil
	Body BlockStmt
}

func (ForStmt) String added in v2.5.0 

func (n ForStmt) String() string

type FuncDecl added in v2.5.0 

type FuncDecl struct {
	Async     bool
	Generator bool
	Name      *Var // can be nil
	Params    Params
	Body      BlockStmt
}

func (FuncDecl) String added in v2.5.0 

func (n FuncDecl) String() string

type GroupExpr added in v2.5.0 

type GroupExpr struct {
	X IExpr
}

func (GroupExpr) String added in v2.5.0 

func (n GroupExpr) String() string

type IBinding added in v2.5.0 

type IBinding interface {
	String() string
	// contains filtered or unexported methods
}

type IExpr added in v2.5.0 

type IExpr interface {
	String() string
	// contains filtered or unexported methods
}

type IStmt added in v2.5.0 

type IStmt interface {
	String() string
	// contains filtered or unexported methods
}

type IfStmt added in v2.5.0 

type IfStmt struct {
	Cond IExpr
	Body IStmt
	Else IStmt // can be nil
}

func (IfStmt) String added in v2.5.0 

func (n IfStmt) String() string

type ImportMetaExpr added in v2.5.0 

type ImportMetaExpr struct {
}

func (ImportMetaExpr) String added in v2.5.0 

func (n ImportMetaExpr) String() string

type ImportStmt added in v2.5.0 

type ImportStmt struct {
	List    []Alias
	Default []byte // can be nil
	Module  []byte
}

func (ImportStmt) String added in v2.5.0 

func (n ImportStmt) String() string

type IndexExpr added in v2.5.0 

type IndexExpr struct {
	X     IExpr
	Index IExpr
	Prec  OpPrec
}

func (IndexExpr) String added in v2.5.0 

func (n IndexExpr) String() string

type LabelledStmt added in v2.5.0 

type LabelledStmt struct {
	Label []byte
	Value IStmt
}

func (LabelledStmt) String added in v2.5.0 

func (n LabelledStmt) String() string

type Lexer 

type Lexer struct {
	// contains filtered or unexported fields
}

Lexer is the state for the lexer.

func NewLexer 

func NewLexer(r *parse.Input) *Lexer

NewLexer returns a new Lexer for a given io.Reader.

Example 
l := NewLexer(parse.NewInputString("var x = 'lorem ipsum';"))
out := ""
for {
	tt, data := l.Next()
	if tt == ErrorToken {
		break
	}
	out += string(data)
}
fmt.Println(out)

Output:

var x = 'lorem ipsum';

func (*Lexer) Err 

func (l *Lexer) Err() error

Err returns the error encountered during lexing, this is often io.EOF but also other errors can be returned.

func (*Lexer) Next 

func (l *Lexer) Next() (TokenType, []byte)

Next returns the next Token. It returns ErrorToken when an error was encountered. Using Err() one can retrieve the error message.

func (*Lexer) RegExp added in v2.5.0 

func (l *Lexer) RegExp() (TokenType, []byte)

RegExp reparses the input stream for a regular expression. It is assumed that we just received DivToken or DivEqToken with Next(). This function will go back and read that as a regular expression.

type LiteralExpr added in v2.5.0 

type LiteralExpr struct {
	TokenType
	Data []byte
}

func (LiteralExpr) String added in v2.5.0 

func (n LiteralExpr) String() string

type MethodDecl added in v2.5.0 

type MethodDecl struct {
	Static    bool
	Async     bool
	Generator bool
	Get       bool
	Set       bool
	Name      PropertyName
	Params    Params
	Body      BlockStmt
}

func (MethodDecl) String added in v2.5.0 

func (n MethodDecl) String() string

type NewExpr added in v2.5.0 

type NewExpr struct {
	X    IExpr
	Args *Arguments // can be nil
}

func (NewExpr) String added in v2.5.0 

func (n NewExpr) String() string

type NewTargetExpr added in v2.5.0 

type NewTargetExpr struct {
}

func (NewTargetExpr) String added in v2.5.0 

func (n NewTargetExpr) String() string

type ObjectExpr added in v2.5.0 

type ObjectExpr struct {
	List []Property
}

func (ObjectExpr) String added in v2.5.0 

func (n ObjectExpr) String() string

type OpPrec added in v2.5.0 

type OpPrec int
const (
	OpExpr     OpPrec = iota // a,b
	OpAssign                 // a?b:c, yield x, ()=>x, async ()=>x, a=b, a+=b, ...
	OpCoalesce               // a??b
	OpOr                     // a||b
	OpAnd                    // a&&b
	OpBitOr                  // a|b
	OpBitXor                 // a^b
	OpBitAnd                 // a&b
	OpEquals                 // a==b, a!=b, a===b, a!==b
	OpCompare                // a<b, a>b, a<=b, a>=b, a instanceof b, a in b
	OpShift                  // a<<b, a>>b, a>>>b
	OpAdd                    // a+b, a-b
	OpMul                    // a*b, a/b, a%b
	OpExp                    // a**b
	OpUnary                  // ++x, --x, delete x, void x, typeof x, +x, -x, ~x, !x, await x
	OpUpdate                 // x++, x--
	OpLHS                    // CallExpr/OptChainExpr or NewExpr
	OpCall                   // a?.b, a(b), super(a), import(a)
	OpNew                    // new a
	OpMember                 // a[b], a.b, a`b`, super[x], super.x, new.target, import.meta, new a(b)
	OpPrimary                // literal, function, class, parenthesized
)

func (OpPrec) String added in v2.5.0 

func (prec OpPrec) String() string

type OptChainExpr added in v2.5.0 

type OptChainExpr struct {
	X IExpr
	Y IExpr // can be CallExpr, IndexExpr, LiteralExpr, or TemplateExpr
}

func (OptChainExpr) String added in v2.5.0 

func (n OptChainExpr) String() string

type Params added in v2.5.0 

type Params struct {
	List []BindingElement
	Rest IBinding // can be nil
}

func (Params) String added in v2.5.0 

func (n Params) String() string

type Parser added in v2.5.0 

type Parser struct {
	// contains filtered or unexported fields
}

Parser is the state for the parser.

type Property added in v2.5.0 

type Property struct {
	// either Name or Spread are set. When Spread is set then Value is AssignmentExpression
	// if Init is set then Value is IdentifierReference, otherwise it can also be MethodDefinition
	Name   *PropertyName // can be nil
	Spread bool
	Value  IExpr
	Init   IExpr // can be nil
}

func (Property) String added in v2.5.0 

func (n Property) String() string

type PropertyName added in v2.5.0 

type PropertyName struct {
	Literal  LiteralExpr
	Computed IExpr // can be nil
}

func (PropertyName) IsComputed added in v2.5.0 

func (n PropertyName) IsComputed() bool

func (PropertyName) IsIdent added in v2.5.0 

func (n PropertyName) IsIdent(data []byte) bool

func (PropertyName) IsSet added in v2.5.0 

func (n PropertyName) IsSet() bool

func (PropertyName) String added in v2.5.0 

func (n PropertyName) String() string

type ReturnStmt added in v2.5.0 

type ReturnStmt struct {
	Value IExpr // can be nil
}

func (ReturnStmt) String added in v2.5.0 

func (n ReturnStmt) String() string

type Scope added in v2.5.0 

type Scope struct {
	Parent, Func   *Scope   // Parent is nil for global scope, Parent equals Func for function scope
	Declared       VarArray // Link in Var are always nil
	Undeclared     VarArray
	NumVarDecls    uint16 // number of variable declaration statements in a function scope
	NumArguments   uint16 // offset into Undeclared to mark variables used in arguments
	IsGlobalOrFunc bool
	HasWith        bool
}

Scope is a function or block scope with a list of variables declared and used

func (*Scope) Declare added in v2.5.0 

func (s *Scope) Declare(decl DeclType, name []byte) (*Var, bool)

Declare a new variable

func (*Scope) HoistUndeclared added in v2.5.0 

func (s *Scope) HoistUndeclared()

func (*Scope) MarkArguments added in v2.5.0 

func (s *Scope) MarkArguments()

func (Scope) String added in v2.5.0 

func (s Scope) String() string

func (*Scope) UndeclareScope added in v2.5.0 

func (s *Scope) UndeclareScope()

func (*Scope) Use added in v2.5.0 

func (s *Scope) Use(name []byte) *Var

Use a variable

type SwitchStmt added in v2.5.0 

type SwitchStmt struct {
	Init IExpr
	List []CaseClause
}

func (SwitchStmt) String added in v2.5.0 

func (n SwitchStmt) String() string

type TemplateExpr added in v2.5.0 

type TemplateExpr struct {
	Tag  IExpr // can be nil
	List []TemplatePart
	Tail []byte
	Prec OpPrec
}

func (TemplateExpr) String added in v2.5.0 

func (n TemplateExpr) String() string

type TemplatePart added in v2.5.0 

type TemplatePart struct {
	Value []byte
	Expr  IExpr
}

type ThrowStmt added in v2.5.0 

type ThrowStmt struct {
	Value IExpr
}

func (ThrowStmt) String added in v2.5.0 

func (n ThrowStmt) String() string

type TokenType 

type TokenType uint16 // from LSB to MSB: 8 bits for tokens per category, 1 bit for numeric, 1 bit for punctuator, 1 bit for operator, 1 bit for identifier, 4 bits unused

TokenType determines the type of token, eg. a number or a semicolon. 

const (
	ErrorToken TokenType = iota // extra token when errors occur
	WhitespaceToken
	LineTerminatorToken // \r \n \r\n
	CommentToken
	CommentLineTerminatorToken
	StringToken
	TemplateToken
	TemplateStartToken
	TemplateMiddleToken
	TemplateEndToken
	RegExpToken
)

TokenType values. 

const (
	NumericToken TokenType = 0x0100 + iota
	DecimalToken
	BinaryToken
	OctalToken
	HexadecimalToken
	BigIntToken
)
const (
	PunctuatorToken   TokenType = 0x0200 + iota
	OpenBraceToken              // {
	CloseBraceToken             // }
	OpenParenToken              // (
	CloseParenToken             // )
	OpenBracketToken            // [
	CloseBracketToken           // ]
	DotToken                    // .
	SemicolonToken              // ;
	CommaToken                  // ,
	QuestionToken               // ?
	ColonToken                  // :
	ArrowToken                  // =>
	EllipsisToken               // ...
)
const (
	OperatorToken TokenType = 0x0600 + iota
	EqToken                 // =
	EqEqToken               // ==
	EqEqEqToken             // ===
	NotToken                // !
	NotEqToken              // !=
	NotEqEqToken            // !==
	LtToken                 // <
	LtEqToken               // <=
	LtLtToken               // <<
	LtLtEqToken             // <<=
	GtToken                 // >
	GtEqToken               // >=
	GtGtToken               // >>
	GtGtEqToken             // >>=
	GtGtGtToken             // >>>
	GtGtGtEqToken           // >>>=
	AddToken                // +
	AddEqToken              // +=
	IncrToken               // ++
	SubToken                // -
	SubEqToken              // -=
	DecrToken               // --
	MulToken                // *
	MulEqToken              // *=
	ExpToken                // **
	ExpEqToken              // **=
	DivToken                // /
	DivEqToken              // /=
	ModToken                // %
	ModEqToken              // %=
	BitAndToken             // &
	BitOrToken              // |
	BitXorToken             // ^
	BitNotToken             // ~
	BitAndEqToken           // &=
	BitOrEqToken            // |=
	BitXorEqToken           // ^=
	AndToken                // &&
	OrToken                 // ||
	NullishToken            // ??
	OptChainToken           // ?.

	// unused in lexer
	PosToken      // +a
	NegToken      // -a
	PreIncrToken  // ++a
	PreDecrToken  // --a
	PostIncrToken // a++
	PostDecrToken // a--
)
const (
	ReservedToken TokenType = 0x0800 + iota
	AwaitToken
	BreakToken
	CaseToken
	CatchToken
	ClassToken
	ConstToken
	ContinueToken
	DebuggerToken
	DefaultToken
	DeleteToken
	DoToken
	ElseToken
	EnumToken
	ExportToken
	ExtendsToken
	FalseToken
	FinallyToken
	ForToken
	FunctionToken
	IfToken
	ImportToken
	InToken
	InstanceofToken
	NewToken
	NullToken
	ReturnToken
	SuperToken
	SwitchToken
	ThisToken
	ThrowToken
	TrueToken
	TryToken
	TypeofToken
	YieldToken
	VarToken
	VoidToken
	WhileToken
	WithToken
)
const (
	IdentifierToken TokenType = 0x1000 + iota
	AsToken
	AsyncToken
	FromToken
	GetToken
	ImplementsToken
	InterfaceToken
	LetToken
	MetaToken
	OfToken
	PackageToken
	PrivateToken
	ProtectedToken
	PublicToken
	SetToken
	StaticToken
	TargetToken
)

func (TokenType) Bytes added in v2.5.0 

func (tt TokenType) Bytes() []byte

Bytes returns the string representation of a TokenType.

func (TokenType) String 

func (tt TokenType) String() string

String returns the string representation of a TokenType.

type TryStmt added in v2.5.0 

type TryStmt struct {
	Body    BlockStmt
	Binding IBinding   // can be nil
	Catch   *BlockStmt // can be nil
	Finally *BlockStmt // can be nil
}

func (TryStmt) String added in v2.5.0 

func (n TryStmt) String() string

type UnaryExpr added in v2.5.0 

type UnaryExpr struct {
	Op TokenType
	X  IExpr
}

func (UnaryExpr) String added in v2.5.0 

func (n UnaryExpr) String() string

type Var 

type Var struct {
	Decl DeclType
	Data []byte
	Link *Var // is set when merging variable uses, as in:  {a} {var a}  where the first lins to the second
	Uses uint16
}

Var is a variable, where Decl is the type of declaration and can be var|function for function scoped variables, let|const|class for block scoped variables

func (*Var) Name added in v2.5.0 

func (v *Var) Name() []byte

func (*Var) String added in v2.5.0 

func (v *Var) String() string

type VarArray added in v2.5.0 

type VarArray []*Var

func (VarArray) String added in v2.5.0 

func (vs VarArray) String() string

type VarDecl added in v2.5.0 

type VarDecl struct {
	TokenType
	List []BindingElement
}

func (VarDecl) String added in v2.5.0 

func (n VarDecl) String() string

type VarsByUses added in v2.5.0 

type VarsByUses VarArray

VarsByUses is sortable by uses in descending order

func (VarsByUses) Len added in v2.5.0 

func (vs VarsByUses) Len() int

func (VarsByUses) Less added in v2.5.0 

func (vs VarsByUses) Less(i, j int) bool

func (VarsByUses) Swap added in v2.5.0 

func (vs VarsByUses) Swap(i, j int)

type WhileStmt added in v2.5.0 

type WhileStmt struct {
	Cond IExpr
	Body IStmt
}

func (WhileStmt) String added in v2.5.0 

func (n WhileStmt) String() string

type WithStmt added in v2.5.0 

type WithStmt struct {
	Cond IExpr
	Body IStmt
}

func (WithStmt) String added in v2.5.0 

func (n WithStmt) String() string

type YieldExpr added in v2.5.0 

type YieldExpr struct {
	Generator bool
	X         IExpr // can be nil
}

func (YieldExpr) String added in v2.5.0 

func (n YieldExpr) String() string

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.