Support selector.

Author: hsluoyz

parse/expression.go

@@ -23,6 +23,7 @@ const (
 	ExpressionTypeCall
 	ExpressionTypeIndex
 	ExpressionTypeStar
+	ExpressionTypeSelector
 	ExpressionTypeParameter
 	ExpressionTypeResult
 )
@@ -49,6 +50,9 @@ func (expr *Expression) String() string {
 	case ExpressionTypeStar:
 		// *flag
 		res = fmt.Sprintf("*%s", expr.Children[0])
+	case ExpressionTypeSelector:
+		// fmt.Printf, object.Event, ..
+		res = fmt.Sprintf("%s.%s", expr.Children[0], expr.Name)
 	default:
 		res = expr.Name
 	}

parse/expression_parse.go

@@ -124,6 +124,20 @@ func parseStarExpression(expr *ast.StarExpr) *Expression {
 	return res
 }
 
+func parseSelectorExpression(expr *ast.SelectorExpr) *Expression {
+	// Selector expression like:
+	// fmt.Printf
+	before := parseExpression(&expr.X) // fmt
+	after := expr.Sel.Name             // Printf
+
+	res := &Expression{
+		Type:     ExpressionTypeSelector,
+		Name:     after,               // Printf
+		Children: Expressions{before}, // fmt
+	}
+	return res
+}
+
 func parseExpression(expr *ast.Expr) *Expression {
 	e, ok := (*expr).(*ast.BasicLit)
 	if ok {
@@ -165,5 +179,10 @@ func parseExpression(expr *ast.Expr) *Expression {
 		return parseStarExpression(e8)
 	}
 
+	e9, ok := (*expr).(*ast.SelectorExpr)
+	if ok {
+		return parseSelectorExpression(e9)
+	}
+
 	panic("parseExpression(): unknown expression type")
 }

parse/name_type_parse.go

@@ -23,6 +23,12 @@ func parseStarNameType(nameType *ast.StarExpr) string {
 	return parseNameType(&nameType.X) + "*"
 }
 
+func parseSelectorNameType(expr *ast.SelectorExpr) string {
+	// Selector type like:
+	// object.Event
+	return parseSelectorExpression(expr).String()
+}
+
 func parseNameType(nameType *ast.Expr) string {
 	e, ok := (*nameType).(*ast.Ident)
 	if ok {
@@ -39,5 +45,10 @@ func parseNameType(nameType *ast.Expr) string {
 		return parseStarNameType(e3)
 	}
 
+	e4, ok := (*nameType).(*ast.SelectorExpr)
+	if ok {
+		return parseSelectorNameType(e4)
+	}
+
 	panic("parseNameType(): unknown name type")
 }

parse/statement_parse.go

@@ -11,21 +11,18 @@ import (
 func parseCallStatement(stmt *ast.ExprStmt, level int) *Statement {
 	expr := stmt.X.(*ast.CallExpr)
 
-	fun := expr.Fun.(*ast.SelectorExpr)
-	x := fun.X.(*ast.Ident).Name
-	sel := fun.Sel.Name
-	name := x + "." + sel
+	name := parseSelectorExpression(expr.Fun.(*ast.SelectorExpr)).String()
 
-	exprs := []*Expression{}
+	args := []*Expression{}
 	for _, arg := range expr.Args {
 		expr := parseExpression(&arg)
-		exprs = append(exprs, expr)
+		args = append(args, expr)
 	}
 
 	s := &Statement{
 		Level: level,
 		Name:  name,
-		Args:  exprs,
+		Args:  args,
 	}
 	return s
 }

parse/test.go

@@ -1,18 +1,22 @@
 package parse
 
-import "fmt"
+import (
+	"fmt"
 
-func test(a string, bb []*int) int {
+	"github.com/microsoft/mouselog/object"
+)
+
+func test(a string, events []*object.Event) (int, string) {
 	fmt.Printf("Hello, World!\n")
 	res := 0
 	array := []int{1, 2}
 	for i := 0; i < 10; i++ {
 		res += 10 / 2
 		array = append(array, 1)
-		if res != 10 && (array[0] >= 10 || *bb[3] == 5) {
+		if res != 10 && (array[0] >= 10 || events[3].X == 5) {
 			continue
 		}
 	}
 
-	return res
+	return res, a
 }