حفر عمیق تر به کد با درخت نشانگر: چگونه می توان از درخت نحو خود پرس و جو کرد

package main

import "fmt"

func add(num1 int32, num2 int32) int32 {
    return num1 + num2
}

func subtract(num1, num2 int32) int32 {
    return num1 - num2
}

func calculator(operator string, num1, num2 int32) int32 {
    switch operator {
    case "+":
        return add(num1, num2)
    case "-":
        return subtract(num1, num2)
    default:
        fmt.Errorf("Unknown operator")
    }

    return -1
}

(source_file
  (package_clause
    (package_identifier))

  (import_declaration
    (import_spec
      path: (interpreted_string_literal)))

  (function_declaration
    name: (identifier)
    parameters: (parameter_list
      (parameter_declaration
        name: (identifier)
        type: (type_identifier))
      (parameter_declaration
        name: (identifier)
        type: (type_identifier)))
    result: (type_identifier)
    body: (block
      (return_statement
        (expression_list
          (binary_expression
            left: (identifier)
            right: (identifier))))))

  (function_declaration
    name: (identifier)
    parameters: (parameter_list
      (parameter_declaration
        name: (identifier)
        name: (identifier)
        type: (type_identifier)))
    result: (type_identifier)
    body: (block
      (return_statement
        (expression_list
          (binary_expression
            left: (identifier)
            right: (identifier))))))

  (function_declaration
    name: (identifier)
    parameters: (parameter_list
      (parameter_declaration
        name: (identifier)
        type: (type_identifier))
      (parameter_declaration
        name: (identifier)
        name: (identifier)
        type: (type_identifier)))
    result: (type_identifier)
    body: (block
      (expression_switch_statement
        value: (identifier)

        (expression_case
          value: (expression_list
            (interpreted_string_literal))
          (return_statement
            (expression_list
              (call_expression
                function: (identifier)
                arguments: (argument_list
                  (identifier)
                  (identifier))))))

        (expression_case
          value: (expression_list
            (interpreted_string_literal))
          (return_statement
            (expression_list
              (call_expression
                function: (identifier)
                arguments: (argument_list
                  (identifier)
                  (identifier))))))

        (default_case
          (expression_statement
            (call_expression
              function: (selector_expression
                operand: (identifier)
                field: (field_identifier))
              arguments: (argument_list
                (interpreted_string_literal))))))

      (return_statement
        (expression_list
          (unary_expression
            operand: (int_literal))))))
)

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    tree_sitter "github.com/smacker/go-tree-sitter"
    "github.com/smacker/go-tree-sitter/golang"
)

func main() {
    parser := tree_sitter.NewParser()
    parser.SetLanguage(golang.GetLanguage())

    data, err := os.ReadFile("example.go")
    if err != nil {
        log.Fatal(err)
    }
    tree, err := parser.ParseCtx(context.Background(), nil, data)
    if err != nil {
        log.Fatal(err)
    }

    root := tree.RootNode()
    fmt.Println("Root type:", root.Type())
    fmt.Println("Tree:
", root.String())
}

(function_declaration
    name: (identifier)
    parameters: (parameter_list)
    result: (type_identifier)
    body: (block)
)

(function_declaration
    name: (identifier) @function-name
)

package main

import (
    "context"
    "fmt"
    "log"
    "os"

    tree_sitter "github.com/smacker/go-tree-sitter"
    "github.com/smacker/go-tree-sitter/golang"
)

var (
    function_declarations_query = `
        (function_declaration
            name: (identifier) @function-name
        )
    `
)

func main() {
    parser := tree_sitter.NewParser()
    parser.SetLanguage(golang.GetLanguage())

    data, err := os.ReadFile("example.go")
    if err != nil {
        log.Fatal(err)
    }
    tree, err := parser.ParseCtx(context.Background(), nil, data)
    if err != nil {
        log.Fatal(err)
    }

    query, err := tree_sitter.NewQuery([]byte(function_declarations_query), golang.GetLanguage())
    if err != nil {
        log.Fatal(err)
    }

    cursor := tree_sitter.NewQueryCursor()
    cursor.Exec(query, tree.RootNode())

    for {
        match, more := cursor.NextMatch()
        if !more {
            break
        }

        for _, capture := range match.Captures {
            node := capture.Node
            fmt.Println("Found function:", node.Content(data))
        }
    }
}

$ go run main.go 
Found function: add
Found function: subtract
Found function: calculator

(function_declaration
    name: (identifier) @function-name
    parameters: (parameter_list) @parameter-list
)

$ go run main.go 
Found function: add
Parameters list: (num1 int32, num2 int32)
Found function: subtract
Parameters list: (num1, num2 int32)
Found function: calculator
Parameters list: (operator string, num1, num2 int32)