go positions 源码
golang positions 代码
文件路径：/src/cmd/compile/internal/syntax/positions.go
// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// This file implements helper functions for scope position computations.
package syntax
// StartPos returns the start position of n.
func StartPos(n Node) Pos {
// Cases for nodes which don't need a correction are commented out.
for m := n; ; {
switch n := m.(type) {
case nil:
panic("nil node")
// packages
case *File:
// file block starts at the beginning of the file
return MakePos(n.Pos().Base(), 1, 1)
// declarations
// case *ImportDecl:
// case *ConstDecl:
// case *TypeDecl:
// case *VarDecl:
// case *FuncDecl:
// expressions
// case *BadExpr:
// case *Name:
// case *BasicLit:
case *CompositeLit:
if n.Type != nil {
m = n.Type
continue
}
return n.Pos()
// case *KeyValueExpr:
// case *FuncLit:
// case *ParenExpr:
case *SelectorExpr:
m = n.X
case *IndexExpr:
m = n.X
// case *SliceExpr:
case *AssertExpr:
m = n.X
case *TypeSwitchGuard:
if n.Lhs != nil {
m = n.Lhs
continue
}
m = n.X
case *Operation:
if n.Y != nil {
m = n.X
continue
}
return n.Pos()
case *CallExpr:
m = n.Fun
case *ListExpr:
if len(n.ElemList) > 0 {
m = n.ElemList[0]
continue
}
return n.Pos()
// types
// case *ArrayType:
// case *SliceType:
// case *DotsType:
// case *StructType:
// case *Field:
// case *InterfaceType:
// case *FuncType:
// case *MapType:
// case *ChanType:
// statements
// case *EmptyStmt:
// case *LabeledStmt:
// case *BlockStmt:
// case *ExprStmt:
case *SendStmt:
m = n.Chan
// case *DeclStmt:
case *AssignStmt:
m = n.Lhs
// case *BranchStmt:
// case *CallStmt:
// case *ReturnStmt:
// case *IfStmt:
// case *ForStmt:
// case *SwitchStmt:
// case *SelectStmt:
// helper nodes
case *RangeClause:
if n.Lhs != nil {
m = n.Lhs
continue
}
m = n.X
// case *CaseClause:
// case *CommClause:
default:
return n.Pos()
}
}
}
// EndPos returns the approximate end position of n in the source.
// For some nodes (*Name, *BasicLit) it returns the position immediately
// following the node; for others (*BlockStmt, *SwitchStmt, etc.) it
// returns the position of the closing '}'; and for some (*ParenExpr)
// the returned position is the end position of the last enclosed
// expression.
// Thus, EndPos should not be used for exact demarcation of the
// end of a node in the source; it is mostly useful to determine
// scope ranges where there is some leeway.
func EndPos(n Node) Pos {
for m := n; ; {
switch n := m.(type) {
case nil:
panic("nil node")
// packages
case *File:
return n.EOF
// declarations
case *ImportDecl:
m = n.Path
case *ConstDecl:
if n.Values != nil {
m = n.Values
continue
}
if n.Type != nil {
m = n.Type
continue
}
if l := len(n.NameList); l > 0 {
m = n.NameList[l-1]
continue
}
return n.Pos()
case *TypeDecl:
m = n.Type
case *VarDecl:
if n.Values != nil {
m = n.Values
continue
}
if n.Type != nil {
m = n.Type
continue
}
if l := len(n.NameList); l > 0 {
m = n.NameList[l-1]
continue
}
return n.Pos()
case *FuncDecl:
if n.Body != nil {
m = n.Body
continue
}
m = n.Type
// expressions
case *BadExpr:
return n.Pos()
case *Name:
p := n.Pos()
return MakePos(p.Base(), p.Line(), p.Col()+uint(len(n.Value)))
case *BasicLit:
p := n.Pos()
return MakePos(p.Base(), p.Line(), p.Col()+uint(len(n.Value)))
case *CompositeLit:
return n.Rbrace
case *KeyValueExpr:
m = n.Value
case *FuncLit:
m = n.Body
case *ParenExpr:
m = n.X
case *SelectorExpr:
m = n.Sel
case *IndexExpr:
m = n.Index
case *SliceExpr:
for i := len(n.Index) - 1; i >= 0; i-- {
if x := n.Index[i]; x != nil {
m = x
continue
}
}
m = n.X
case *AssertExpr:
m = n.Type
case *TypeSwitchGuard:
m = n.X
case *Operation:
if n.Y != nil {
m = n.Y
continue
}
m = n.X
case *CallExpr:
if l := lastExpr(n.ArgList); l != nil {
m = l
continue
}
m = n.Fun
case *ListExpr:
if l := lastExpr(n.ElemList); l != nil {
m = l
continue
}
return n.Pos()
// types
case *ArrayType:
m = n.Elem
case *SliceType:
m = n.Elem
case *DotsType:
m = n.Elem
case *StructType:
if l := lastField(n.FieldList); l != nil {
m = l
continue
}
return n.Pos()
// TODO(gri) need to take TagList into account
case *Field:
if n.Type != nil {
m = n.Type
continue
}
m = n.Name
case *InterfaceType:
if l := lastField(n.MethodList); l != nil {
m = l
continue
}
return n.Pos()
case *FuncType:
if l := lastField(n.ResultList); l != nil {
m = l
continue
}
if l := lastField(n.ParamList); l != nil {
m = l
continue
}
return n.Pos()
case *MapType:
m = n.Value
case *ChanType:
m = n.Elem
// statements
case *EmptyStmt:
return n.Pos()
case *LabeledStmt:
m = n.Stmt
case *BlockStmt:
return n.Rbrace
case *ExprStmt:
m = n.X
case *SendStmt:
m = n.Value
case *DeclStmt:
if l := lastDecl(n.DeclList); l != nil {
m = l
continue
}
return n.Pos()
case *AssignStmt:
m = n.Rhs
if m == nil {
p := EndPos(n.Lhs)
return MakePos(p.Base(), p.Line(), p.Col()+2)
}
case *BranchStmt:
if n.Label != nil {
m = n.Label
continue
}
return n.Pos()
case *CallStmt:
m = n.Call
case *ReturnStmt:
if n.Results != nil {
m = n.Results
continue
}
return n.Pos()
case *IfStmt:
if n.Else != nil {
m = n.Else
continue
}
m = n.Then
case *ForStmt:
m = n.Body
case *SwitchStmt:
return n.Rbrace
case *SelectStmt:
return n.Rbrace
// helper nodes
case *RangeClause:
m = n.X
case *CaseClause:
if l := lastStmt(n.Body); l != nil {
m = l
continue
}
return n.Colon
case *CommClause:
if l := lastStmt(n.Body); l != nil {
m = l
continue
}
return n.Colon
default:
return n.Pos()
}
}
}
func lastDecl(list []Decl) Decl {
if l := len(list); l > 0 {
return list[l-1]
}
return nil
}
func lastExpr(list []Expr) Expr {
if l := len(list); l > 0 {
return list[l-1]
}
return nil
}
func lastStmt(list []Stmt) Stmt {
if l := len(list); l > 0 {
return list[l-1]
}
return nil
}
func lastField(list []*Field) *Field {
if l := len(list); l > 0 {
return list[l-1]
}
return nil
}
相关信息
相关文章
0
赞
热门推荐
-
2、 - 优质文章
-
3、 gate.io
-
6、 golang
-
7、 openharmony