Go语言中返回接收者自身的方法的作用

// Token source positions are represented by a Position value.
// A Position is valid if the line number is > 0.
//
type Position struct {
    Filename string // filename, if any
    Offset   int    // byte offset, starting at 0
    Line     int    // line number, starting at 1
    Column   int    // column number, starting at 1 (character count)
}

// Pos is an accessor method for anonymous Position fields.
// It returns its receiver.
//
func (pos *Position) Pos() Position { return *pos }

// Comments

// A Comment node represents a single //-style or /*-style comment.
type Comment struct {
    token.Position // beginning position of the comment
    Text            []byte // comment text (excluding '\n' for //-style comments)
}

package main

import (
    "fmt"
    "go/ast"
    "go/token"
)

func main() {
    comment := ast.Comment{
        Text: []byte("// This is a comment"),
    }

    // Create a token.Position and assign values.  Normally this would be populated
    // by the parser.
    pos := token.Position{
        Filename: "example.go",
        Offset:   0,
        Line:     1,
        Column:   1,
    }

    // We need to set the Position value in the comment struct using reflection
    // because it's an anonymous field and not directly settable.
    // This is just for demonstration purposes.  Normally the parser would
    // populate this value.
    //
    // This is more complex than is reasonable for this example, but it does
    // demonstrate the anonymous field functionality of the Pos() method.
    //
    // NOTE: This is not a good way to set the anonymous field.  It's just
    // a way to demonstrate the anonymous field access.
    //
    // A better way to set the anonymous field would be to use the ast.NewComment()
    // function and then set the Pos field directly.  However, that would not
    // demonstrate the anonymous field access.
    //
    // The reflection approach is used here to demonstrate the anonymous field access.
    //
    // A real parser would populate the Position field directly.
    //
    // You should never do this in production code.
    //
    // Use the ast.NewComment() function and then set the Pos field directly.
    //
    // Or, if you are using the parser, it will populate the Position field for you.
    //
    // This example is just to demonstrate the anonymous field access.
    //
    // You have been warned.
    //
    // The following code is a terrible hack.
    //
    // I repeat, do not do this in production code.

    // Get the type of the token.Position field.
    posType := reflect.TypeOf(token.Position{})

    // Get the value of the comment struct.
    commentValue := reflect.ValueOf(&comment).Elem()

    // Get the field of the comment struct that is of type token.Position.
    posFieldValue := commentValue.Field(0)

    // Check that the field is of the correct type.
    if posFieldValue.Type() != posType {
        panic(fmt.Sprintf("Expected field of type %s, got %s", posType, posFieldValue.Type()))
    }

    // Check that the field is addressable.
    if !posFieldValue.CanSet() {
        panic("Field is not addressable")
    }

    // Set the value of the field.
    posFieldValue.Set(reflect.ValueOf(pos))

    // Now we can access the position using the Pos() method.
    commentPosition := comment.Pos()
    fmt.Printf("Comment position: %+v\n", commentPosition)
}