검사 표현식이 구조체의 필드를 확인하는 코드 생성기를 작성

Question

상황

"/ 파서 이동"및 구조체 태그를

문제

를 사용하여 유효성 검사 기능을 추가하여 사용자 정의 유형 인 경우

유형 필드가 맞춤 유형인지 확인해야합니다.

예 :

다음은3210

사용자 정의 유형

int, []int,*int,[]Integer,map[string]PhoneNumber 

되지 않고 다음과

Integer,PhoneNumber,*PhoneNumber 

내가 나는 그것이 정확히 일치하는 외모와지도를 추가 할 수 있습니다 다음과 같은 기능을 사용 할 수 있다고 생각 사용자 정의 형에게, [입니다 ] 지원

func isBuiltInType(typ string) bool { 
    switch typ { 
      case "bool", "byte", "complex128", "complex64", "error": 
      case "float32", "float64": 
      case "int", "int16", "int32", "int64", "int8": 
      case "rune", "string": 
      case "uint", "uint16", "uint32", "uint64", "uint8", "uintptr": 
      default: 
       return false 
    } 
    return true 
} 

그러나 parse.ParseExpr 등

01를 사용하여 할 수있는 더 좋은 방법이

Answer 1

신뢰할 수있는 결과를 얻으려면 go/types 패키지를 사용하여 Go 유형 검사기를 사용해야합니다. 사용하는 것은 간단하지 않지만 https://golang.org/s/types-tutorial에 유용한 소개 기사가 있습니다.

예제 프로그램을 함께 사용하여 예상되는 결과를 볼 수 있습니다. 중요한 비트는 isBasic 함수이며, 나머지는 실행 가능하게 만드는 상용구입니다. 특히 AST 탐색은 특정 샘플 소스 코드에 대해 하드 코드됩니다. 이미 그 자리에 자신의 코드가 있다고 가정합니다.

요점은 types.Info 구조에 자신의 논리를 구현하는 데 필요한 모든 유형 정보가 들어 있다는 것입니다.

코드 생성 및/또는 구문 분석 (전체 유형 정보에 대해 로더 패키지가 필요함)을 처리 할 때 github.com/fatih/astrewrite 및 golang.org/x/tools/go/loader이 도움이되는 것으로 나타났습니다.

https://play.golang.org/p/A9hdPy-Oy-

package main 

import (
    "bufio" 
    "fmt" 
    "go/ast" 
    "go/parser" 
    "go/token" 
    "go/types" 
    "log" 
    "strings" 
) 

var src = strings.TrimSpace(` 
package main 

type T struct{} 

func f() { 
    var _ T 
    var _ *T 

    var _ int 
    var _ *int 
    var _ **int 
    var _ []int 
    var _ []T 
    var _ map[string]int 
    var _ map[string]T 
} 
`) 

func main() { 
    // Parse source 
    fset := token.NewFileSet() 
    f, err := parser.ParseFile(fset, "src.go", src, 0) 
    if err != nil { 
      log.Fatal(err) 
    } 

    // Run type checker 
    info := types.Info{Types: make(map[ast.Expr]types.TypeAndValue)} 

    _, err = (&types.Config{}).Check("mypkg", fset, []*ast.File{f}, &info) 
    if err != nil { 
      log.Fatal(err) 
    } 

    printSrc() 

    // Inspect variable types in f() 
    for _, varDecl := range f.Decls[1].(*ast.FuncDecl).Body.List { 
      value := varDecl.(*ast.DeclStmt).Decl.(*ast.GenDecl).Specs[0].(*ast.ValueSpec) 

      pos := fset.Position(value.Type.Pos()) 
      typ := info.Types[value.Type].Type 

      fmt.Println(pos, "basic:", isBasic(typ)) 
    } 
} 

func isBasic(t types.Type) bool { 
    switch x := t.(type) { 
    case *types.Basic: 
      return true 
    case *types.Slice: 
      return true 
    case *types.Map: 
      return true 
    case *types.Pointer: 
      return isBasic(x.Elem()) 
    default: 
      return false 
    } 
} 

func printSrc() { 
    s := bufio.NewScanner(strings.NewReader(src)) 
    for i := 1; s.Scan(); i++ { 
      fmt.Printf("%2d: %s\n", i, s.Text()) 
    } 
    fmt.Println("") 
}