Golang token.Pos函数代码示例

func (vis *pointerTransformVisitor) makeNewNode(i *ast.Ident, depth int) ast.Expr {
	d := depth
	i.NamePos += token.Pos(d)
	switch {
	case depth > 0:
		res := &ast.UnaryExpr{i.NamePos - token.Pos(depth), token.AND, nil}
		e := res
		for depth > 1 {
			e.X = &ast.UnaryExpr{i.NamePos - token.Pos(depth), token.AND, nil}
			e = e.X.(*ast.UnaryExpr)
			depth--
		}
		e.X = i
		return res
	case depth < 0:
		res := &ast.StarExpr{i.NamePos - token.Pos(depth), nil}
		e := res
		for depth < -1 {
			e.X = &ast.StarExpr{i.NamePos - token.Pos(depth), nil}
			e = e.X.(*ast.StarExpr)
			depth++
		}
		e.X = i
		return res
	}
	return i
}

func (p *parser) parsePackageClause(n *parse.Node) (token.Pos, *ast.Ident) {
	pac, name := n.Child(0), n.Child(1)
	return token.Pos(pac.Pos()), &ast.Ident{
		NamePos: token.Pos(name.Pos()),
		Name:    string(name.Value()),
	}
}

func (p *parser) parseIndex(n *parse.Node) ast.Expr {
	index := n.Child(1)
	return &ast.IndexExpr{
		X:      p.parsePrimaryExpr(n.Child(0)),
		Lbrack: token.Pos(index.Child(0).Pos()),
		Index:  p.parseExpr(index.Child(1)),
		Rbrack: token.Pos(index.Child(2).Pos()),
	}
}

func (p *parser) parseCompositeLit(n *parse.Node) ast.Expr {
	litValue := n.Child(1)
	return &ast.CompositeLit{
		Type:   p.parseLiteralType(n.Child(0)),
		Lbrace: token.Pos(litValue.Child(0).Pos()),
		Elts:   p.parseLiteralValue(litValue),
		Rbrace: token.Pos(litValue.LastChild().Pos()),
	}
}

func (p *parser) parseBlock(n *parse.Node, scope *ast.Scope) *ast.BlockStmt {
	block := ast.BlockStmt{
		Lbrace: token.Pos(n.Child(0).Pos()),
		Rbrace: token.Pos(n.LastChild().Pos()),
	}
	eachListItem(stmt, n.Child(1), func(item *parse.Node) {
		block.List = append(block.List, p.parseStmt(item))
	})
	return &block
}

func GetLines(f *token.File) []int {
	lines := make([]int, 0, 20)
	l := -1
	for i := f.Base(); i < f.Base()+f.Size(); i++ {
		if f.Line(token.Pos(i)) > l {
			l = f.Line(token.Pos(i))
			lines = append(lines, f.Offset(token.Pos(i)))
		}
	}
	return lines
}

func (p *parser) parseCallExpr(n *parse.Node) *ast.CallExpr {
	call := n.Child(1)
	callExpr := ast.CallExpr{
		Fun:    p.parsePrimaryExpr(n.Child(0)),
		Lparen: token.Pos(call.Child(0).Pos()),
		Rparen: token.Pos(call.LastChild().Pos()),
	}
	if call.ChildCount() > 2 {
		callExpr.Args, callExpr.Ellipsis = p.parseArgs(call.Child(1))
	}
	return &callExpr
}

func (p *parser) parseParams(n *parse.Node, scope *ast.Scope) *ast.FieldList {
	fieldList := ast.FieldList{
		Opening: token.Pos(n.Child(0).Pos()),
		Closing: token.Pos(n.LastChild().Pos()),
	}
	if n.Child(1).Is(parameterList) {
		eachListItem(parameterDecl, n.Child(1), func(item *parse.Node) {
			fieldList.List = append(fieldList.List, p.parseParamDecl(item, scope))
		})
	}
	return &fieldList
}

func (p *parser) parseVarDecl(n *parse.Node) ast.Decl {
	var specs []ast.Spec
	lParen, rParen := declListEach(n.Child(1), func(item *parse.Node) {
		specs = append(specs, p.parseVarSpec(item))
	})
	return &ast.GenDecl{
		TokPos: token.Pos(n.Child(0).Pos()),
		Tok:    token.Token(n.Child(0).ID()),
		Lparen: token.Pos(lParen),
		Specs:  specs,
		Rparen: token.Pos(rParen),
	}
}

func makeStmtList(block *vector.Vector) []ast.Stmt {
	stmtList := make([]ast.Stmt, len(*block))
	for i, stmt := range *block {
		switch el := stmt.(type) {
		case ast.Stmt:
			stmtList[i] = el
		case []ast.Expr: // i == 0
			stmtList[i] = &ast.ReturnStmt{el[0].Pos() - token.Pos(7), el}
		case ast.Expr: // i == 0
			stmtList[i] = &ast.ReturnStmt{el.Pos() - token.Pos(7), []ast.Expr{el}}
		}
	}
	return stmtList
}

func commentsBetween(f *ast.File, begin token.Pos, end token.Pos) string {
	var buf bytes.Buffer
	var ignore token.Pos
	ignoreUntilNextGroup := func(c *ast.Comment) {
		ignore = c.Slash + token.Pos(len(c.Text)) + 3 // allow for newlines, tabs, etc..
	}
	for _, group := range f.Comments {
		for _, v := range group.List {
			if v.Slash > begin && v.Slash < end {
				if v.Slash < ignore {
					ignoreUntilNextGroup(v)
				}
				text := strings.TrimSpace(strings.TrimPrefix(v.Text, "//"))
				if text != "" {
					if buf.Len() == 0 && text[0] == '!' {
						// Marked as non-doc comment
						ignoreUntilNextGroup(v)
						continue
					}
					if buf.Len() > 0 {
						buf.WriteByte(' ')
					}
					buf.WriteString(text)
				}
			}
		}
	}
	return buf.String()
}

// BeforeComments rewinds start past any blank lines or line comments
// and return the result. It does not rewind past leading blank lines:
// the returned position, if changed, is always the start of a non-blank line.
func (b *EditBuffer) BeforeComments(start token.Pos) token.Pos {
	i := b.tx(start)
	// Back up to newline.
	for i > 0 && (b.text[i-1] == ' ' || b.text[i-1] == '\t') {
		i--
	}
	if i > 0 && b.text[i-1] != '\n' {
		return start
	}

	// Go backward by lines.
	lastNonBlank := i
	for i > 0 {
		j := i - 1
		for j > 0 && b.text[j-1] != '\n' {
			j--
		}
		trim := strings.TrimSpace(b.text[j:i])
		if len(trim) > 0 && !strings.HasPrefix(trim, "//") {
			break
		}
		if len(trim) > 0 {
			lastNonBlank = j
		}
		i = j
	}
	return start - token.Pos(b.tx(start)-lastNonBlank)
}

func (p *parser) parseBasicLit(n *parse.Node) *ast.BasicLit {
	return &ast.BasicLit{
		ValuePos: token.Pos(n.Pos()),
		Kind:     token.Token(n.ID()),
		Value:    string(n.Value()),
	}
}

func getImports(node *parser.CallNode) ast.Decl {
	if len(node.Args) < 2 {
		return nil
	}

	imports := node.Args[1:]
	specs := make([]ast.Spec, len(imports))

	for i, imp := range imports {
		if t := imp.Type(); t == parser.NodeVector {
			specs[i] = makeImportSpecFromVector(imp.(*parser.VectorNode))
		} else if t == parser.NodeString {
			importPath := imp.(*parser.StringNode).Value
			if importPath[1] == '/' {
				importPath = "\"" + standardLibrary + importPath[1:]
			}
			path := makeBasicLit(token.STRING, importPath)
			specs[i] = makeImportSpec(path, nil)
		} else {
			panic("invalid import!")
		}
	}

	decl := makeGeneralDecl(token.IMPORT, specs)
	decl.Lparen = token.Pos(1) // Need this so we can have multiple imports
	return decl
}

func (p *parser) parseForStmt(n *parse.Node) (r ast.Stmt) {
	p.openScope()
	forPos := token.Pos(n.Child(0).Pos())
	n = n.Child(1)
	if n.Is(block) {
		return &ast.ForStmt{
			For:  forPos,
			Body: p.parseBlock(n, p.topScope),
		}
	}
	option := n.Child(0).Child(0)
	body := p.parseBlock(n.Child(1), p.topScope)
	switch option.Rule() {
	case condition:
		fmt.Println(option)
	case forClause:
		fmt.Println(option)
	case rangeClause:
		forStmt := p.parseRangeStmt(option)
		forStmt.For, forStmt.Body = forPos, body
		r = forStmt
	}
	p.closeScope()
	return
}