从编译器角度出发探索如何在go中实现AOP

// parseFiles concurrently parses files into *syntax.File structures.
// Each declaration in every *syntax.File is converted to a syntax tree
// and its root represented by *Node is appended to xtop.
// Returns the total count of parsed lines.
func parseFiles(filenames []string) uint {...}
如注释所说这里会用多个goroutine来解析文件，最终这个parseFiles函数会将整个文件对应的语法树存到src/compile/internal/gc/noder.go中的noder结构体中，一个 noder 对象相当于 AST 语法树中的节点，构成了整个语法树。noder 结构体定义如下：

// noder transforms package syntax's AST into a Node tree.
type noder struct {
    basemap   map[*syntax.PosBase]*src.PosBase
    basecache struct {
        last *syntax.PosBase
        base *src.PosBase
    }
    file       *syntax.File
    filename   string
    linknames  []linkname
    pragcgobuf [][]string
    err        chan syntax.Error
    scope      ScopeID
    // scopeVars is a stack tracking the number of variables declared in the
    // current function at the moment each open scope was opened.
    scopeVars []int
    lastCloseScopePos syntax.Pos
}

type File struct {
    Pragma   Pragma 
    PkgName  *Name
    DeclList []Decl
    Lines    uint
    node
}

type parser struct {
    file  *PosBase
    errh  ErrorHandler
    mode  Mode
    pragh PragmaHandler
    scanner

    base   *PosBase // current position base
    first  error    // first error encountered
    errcnt int      // number of errors encountered
    pragma Pragma   // pragmas

    fnest  int    // function nesting level (for error handling)
    xnest  int    // expression nesting level (for complit ambiguity resolution)
    indent []byte // tracing support

    imports map[string]string // contents of imports
}

type scanner struct {
    source
    mode   uint
    nlsemi bool // if set '\n' and EOF translate to ';'

    // current token, valid after calling next()
    line, col uint
    blank     bool // line is blank up to col
    tok       token
    lit       string   // valid if tok is _Name, _Literal, or _Semi ("semicolon", "newline", or "EOF"); may be malformed if bad is true
    bad       bool     // valid if tok is _Literal, true if a syntax error occurred, lit may be malformed
    kind      LitKind  // valid if tok is _Literal
    op        Operator // valid if tok is _Operator, _AssignOp, or _IncOp
    prec      int      // valid if tok is _Operator, _AssignOp, or _IncOp
}

// Main parses flags and Go source files specified in the command-line
// arguments, type-checks the parsed Go package, compiles functions to machine
// code, and finally writes the compiled package definition to disk.
func Main(archInit func(*Arch)) {
     ...
     lines := parseFiles(flag.Args())
     ...
}

func parseFiles(filenames []string) uint {
    //  创建 noder 列表
    noders := make([]*noder, 0, len(filenames))
    // 表示最多能同时开启多少个文件描述符
    sem := make(chan struct{}, runtime.GOMAXPROCS(0)+10)

    //  遍历 所有文件
    for _, filename := range filenames {
        //  创建 noder 对现象，并且添加到 noder 列表中
        p := &noder{
            basemap: make(map[*syntax.PosBase]*src.PosBase),
            err:     make(chan syntax.Error),
        }
        noders = append(noders, p)

        //  每个文件用一个 Goroutine 去解析
        go func(filename string) {
            sem <- struct{}{}
            defer func() { <-sem }()
            defer close(p.err)
            base := syntax.NewFileBase(filename)

            f, err := os.Open(filename)
            if err != nil {
                p.error(syntax.Error{Msg: err.Error()})
                return
            }
            defer f.Close()

            //   文件解析的主要过程
            p.file, _ = syntax.Parse(base, f, p.error, p.pragma, syntax.CheckBranches) // errors are tracked via p.error
        }(filename)
    }

    //  下面代码段主要是将 noder 列表中的节点，添加到 xTop 中。
    var lines uint
    for _, p := range noders {
        for e := range p.err {
            p.yyerrorpos(e.Pos, "%s", e.Msg)
        }
        //  node() 方法将 noders 转成 Node 节点，添加到 xtop 这棵树中
        p.node()
        lines += p.file.Lines
        p.file = nil // release memory

        if nsyntaxerrors != 0 {
            errorexit()
        }
        // Always run testdclstack here, even when debug_dclstack is not set, as a sanity measure.
        testdclstack()
    }

    localpkg.Height = myheight

    return lines
}

func Parse(base *PosBase, src io.Reader, errh ErrorHandler, pragh PragmaHandler, mode Mode) (_ *File, first error) {
var p parser
p.init(base, src, errh, pragh, mode)
p.next()（词法分析）
return p.fileOrNil(), p.first
}

// If the scanner mode includes the directives (but not the comments)
// flag, only comments containing a //line, /*line, or //go: directive
// are reported, in the same way as regular comments.
func (s *scanner) next() {
   nlsemi := s.nlsemi
   s.nlsemi = false

type (
    Decl interface {
        Node
        aDecl()
    }

    FuncDecl struct {
        Attr   map[string]bool
        Recv   *Field
        Name   *Name
        Type   *FuncType
        Body   *BlockStmt
        Pragma Pragma
        decl
    }
}

    BlockStmt struct {
        List   []Stmt
        Rbrace Pos
        stmt
    }

git clone https://github.com/golang/go.git
cd $HOME/src/github.com/golang/go
git checkout release-branch.go1.15

mkdir $HOME/go_boostrap
cd $HOME/go_bootstrap
curl https://dl.google.com/go/go1.15.12.darwin-amd64.tar.gz | tar xvzf -
mv go go_bootstrap_15

cd $HOME/src/github.com/golang/go/src
echo 'export GOROOT_BOOTSTRAP=$HOME/go_bootstrap/go1.15.12' >> .envrc

cd $HOME/src/github.com/golang/go/src
./make.bash

export GOROOT=$HOME/src/github.com/golang/go   # 定制版Go的路径
export PATH=$GOROOT/bin:$PATH

package main

import (
    "context"
    "fmt"
 )
 
 func UGO(ctx context.Context) {
     fmt.Println("hello world")
}

func main() {
    hello(context.Background())
}

    defer f.Close()

   p.file, _ = syntax.Parse(base, f, p.error, p.pragma, syntax.CheckBranches) // errors are tracked via p.error
}(filename)

p.file, _ = syntax.Parse(base, f, p.error, p.pragma, syntax.CheckBranches) // errors are tracked via p.error
            if p.file.PkgName.Value == "main" {
                for _, d := range p.file.DeclList {
                    d, _ := d.(*syntax.FuncDecl)
                    if d == nil {
                        continue
                    }
                    if !strings.HasPrefix(d.Name.Value, "UGO") {
                        continue
                    }
                    d.Body.List = append([]syntax.Stmt{
                        &syntax.ExprStmt{
                            X: &syntax.CallExpr{
                                Fun: &syntax.SelectorExpr{
                                    X:   &syntax.Name{Value: "fmt"},
                                    Sel: &syntax.Name{Value: "Println"},
                                },
                                ArgList: []syntax.Expr{
                                    &syntax.BasicLit{
                                        Value: strconv.Quote("start " + d.Name.Value + "..."),
                                        Kind:  syntax.StringLit,
                                    },
                                },
                            },
                        },
                        &syntax.CallStmt{
                            Tok: syntax.Defer,
                            Call: &syntax.CallExpr{
                                Fun: &syntax.SelectorExpr{
                                    X:   &syntax.Name{Value: "fmt"},
                                    Sel: &syntax.Name{Value: "Println"},
                                },
                                ArgList: []syntax.Expr{
                                    &syntax.BasicLit{
                                        Value: strconv.Quote("end " + d.Name.Value + "..."),
                                        Kind:  syntax.StringLit,
                                    },
                                },
                            },
                        },
                    }, d.Body.List...)
                }
            }  

cd $HOME/src/github.com/golang/go/src
./make.bash

cd $HOME/GolangProject/Hello
go clean -cache
go run hello/main.go

start UGO...
hello world
end UGO...

$ go clean -cache; go run Hello/main.go
# command-line-arguments
helloworld/main.go:7:16: undefined: fmt in fmt.Println 

if p.file.PkgName.Value == "main" {
                for _, d := range p.file.DeclList {
                    d, _ := d.(*syntax.FuncDecl)
                    if d == nil {
                        continue
                    }
                    if !strings.HasPrefix(d.Name.Value, "hello") {
                        continue
                    }
                    hasHello = true
                    d.Body.List = append([]syntax.Stmt{
                        &syntax.ExprStmt{
                            X: &syntax.CallExpr{
                                Fun: &syntax.SelectorExpr{
                                    X:   &syntax.Name{Value: "fmt"},
                                    Sel: &syntax.Name{Value: "Println"},
                                },
                                ArgList: []syntax.Expr{
                                    &syntax.BasicLit{
                                        Value: strconv.Quote("start " + d.Name.Value + "..."),
                                        Kind:  syntax.StringLit,
                                    },
                                },
                            },
                        },
                        &syntax.CallStmt{
                            Tok: syntax.Defer,
                            Call: &syntax.CallExpr{
                                Fun: &syntax.SelectorExpr{
                                    X:   &syntax.Name{Value: "fmt"},
                                    Sel: &syntax.Name{Value: "Println"},
                                },
                                ArgList: []syntax.Expr{
                                    &syntax.BasicLit{
                                        Value: strconv.Quote("end " + d.Name.Value + "..."),
                                        Kind:  syntax.StringLit,
                                    },
                                },
                            },
                        },
                    }, d.Body.List...)
                }
            }
            if hasHello {
                hasFmtImport := false
                for _, d := range p.file.DeclList {
                    d, _ := d.(*syntax.ImportDecl)
                    if d == nil {
                        continue
                    }
                    if d.Path.Value != "fmt" {
                        continue
                    }
                    hasFmtImport = true
                    break
                }
                if !hasFmtImport {
                    p.file.DeclList = append([]syntax.Decl{
                        &syntax.ImportDecl{
                            Path: &syntax.BasicLit{
                                Value: `"fmt"`, Kind: syntax.StringLit,
                            },
                        },
                    }, p.file.DeclList...)
                }
            }  

$ go clean -cache; go run Hello/main.go
# command-line-arguments
Hello/main.go:1:9: can't find import: "fmt"

if packageFile != nil {
        file, ok = packageFile[name]
        return file, ok
    }  

func readImportCfg(file string) {
   packageFile = map[string]string{}
   data, err := ioutil.ReadFile(file)
   if err != nil {
      log.Fatalf("-importcfg: %v", err)
   }

// Prepare Go import config.
// We start it off with a comment so it can't be empty, so icfg.Bytes() below is never nil.
// It should never be empty anyway, but there have been bugs in the past that resulted
// in empty configs, which then unfortunately turn into "no config passed to compiler",
// and the compiler falls back to looking in pkg itself, which mostly works,
// except when it doesn't.
var icfg bytes.Buffer
fmt.Fprintf(&icfg, "# import config\n")
for i, raw := range a.Package.Internal.RawImports {
   final := a.Package.Imports[i]
   if final != raw {
      fmt.Fprintf(&icfg, "importmap %s=%s\n", raw, final)
   }
}

        pf, err := parser.ParseFile(fset, filename, data, parser.ImportsOnly|parser.ParseComments)
        if err != nil {
            badFile(err)
            continue
        }

// add import
hasFmtImport := false
hasEcodingJsonImport := false
hasRuntime := false
for _, i := range pf.Imports {
   if i.Path.Value == `"fmt"` {
      hasFmtImport = true
   }
   if hasFmtImport && hasEcodingJsonImport && hasRuntime {
      break
   }
}

//if !onlyMain && !hasFmtImport {
if !hasFmtImport {
   pf.Imports = append(pf.Imports, &ast.ImportSpec{
      Path: &ast.BasicLit{
         Value: `"fmt"`,
         Kind:  token.STRING,
      },
   })
   if len(pf.Decls) > 0 {
      d, ok := pf.Decls[0].(*ast.GenDecl)
      if ok {
         d.Specs = append(d.Specs, &ast.ImportSpec{
            Path: &ast.BasicLit{
               Kind:  token.STRING,
               Value: `"fmt"`,
            },
         })
      } else {
         // case : no import
         pf.Decls = append([]ast.Decl{
            &ast.GenDecl{
               Specs: []ast.Spec{
                  &ast.ImportSpec{
                     Path: &ast.BasicLit{
                        Kind:  token.STRING,
                        Value: `"fmt"`,
                     },
                  },
               },
            },
         }, pf.Decls...)
      }
   } else {
      pf.Decls = append([]ast.Decl{
         &ast.GenDecl{
            Specs: []ast.Spec{
               &ast.ImportSpec{
                  Path: &ast.BasicLit{
                     Kind:  token.STRING,
                     Value: `"fmt"`,
                  },
               },
            },
         },
      }, pf.Decls...)
   }

$ go clean -cache; go run helloworld/main.go
start UGO...
hello world
end UGO...