util

Documentation

Index

• Constants
• func FromPtr[T any](p *T) T
• func PathEnclosingInterval(root *ast.File, start, end token.Pos) (path []ast.Node, exact bool)
• func SplitGoptMethod(name string) (recvTypeName string, methodName string, ok bool)
• func ToPtr[T any](v T) *T

Constants

const (
	GoptPrefix = "Gopt_" // Go+ template method
	GopoPrefix = "Gopo_" // Go+ overload function/method
	GopxPrefix = "Gopx_" // Go+ type as parameters function/method
	GopPackage = "GopPackage"
)

Functions

func FromPtr

func FromPtr[T any](p *T) T

FromPtr returns the value from a pointer. It returns the zero value of type T if the pointer is nil.

func PathEnclosingInterval

func PathEnclosingInterval(root *ast.File, start, end token.Pos) (path []ast.Node, exact bool)

PathEnclosingInterval returns the node that encloses the source interval [start, end), and all its ancestors up to the AST root.

The definition of "enclosing" used by this function considers additional whitespace abutting a node to be enclosed by it. In this example:

z := x + y // add them
     <-A->
    <----B----->

the ast.BinaryExpr(+) node is considered to enclose interval B even though its [Pos()..End()) is actually only interval A. This behaviour makes user interfaces more tolerant of imperfect input.

This function treats tokens as nodes, though they are not included in the result. e.g. PathEnclosingInterval("+") returns the enclosing ast.BinaryExpr("x + y").

If start==end, the 1-char interval following start is used instead.

The 'exact' result is true if the interval contains only path[0] and perhaps some adjacent whitespace. It is false if the interval overlaps multiple children of path[0], or if it contains only interior whitespace of path[0]. In this example:

z := x + y // add them
  <--C-->     <---E-->
    ^
    D

intervals C, D and E are inexact. C is contained by the z-assignment statement, because it spans three of its children (:=, x, +). So too is the 1-char interval D, because it contains only interior whitespace of the assignment. E is considered interior whitespace of the BlockStmt containing the assignment.

The resulting path is never empty; it always contains at least the 'root' *ast.File. Ideally PathEnclosingInterval would reject intervals that lie wholly or partially outside the range of the file, but unfortunately ast.File records only the token.Pos of the 'package' keyword, but not of the start of the file itself.

func SplitGoptMethod

func SplitGoptMethod(name string) (recvTypeName string, methodName string, ok bool)

SplitGoptMethod splits a Go+ template method name into receiver type name and method name.

func ToPtr

func ToPtr[T any](v T) *T

ToPtr returns a pointer to the value.