Support negative integer, sometimes name type cannot be retrieved.

Author: hsluoyz

parse/expression_parse.go

@@ -56,6 +56,21 @@ func parseBinaryExpression(expr *ast.BinaryExpr) *Expression {
 	return res
 }
 
+func parseUnaryExpression(expr *ast.UnaryExpr) *Expression {
+	// Unary expression like:
+	// -1
+	op := expr.Op.String()
+	inside := parseExpression(&expr.X)
+	value := fmt.Sprintf("%s%s", op, inside)
+
+	res := &Expression{
+		Type:     ExpressionTypeDefault,
+		Name:     value,
+		NameType: op,
+	}
+	return res
+}
+
 func parseParenthesesExpression(expr *ast.ParenExpr) *Expression {
 	// Parentheses expression like:
 	// (1 + 2)
@@ -89,7 +104,7 @@ func parseCallExpression(expr *ast.CallExpr) *Expression {
 	// append(array, 1)
 	res := &Expression{
 		Type: ExpressionTypeCall,
-		Name: expr.Fun.(*ast.Ident).Name,
+		Name: parseExpression(&expr.Fun).String(),
 	}
 
 	res.Children = Expressions{}
@@ -154,34 +169,39 @@ func parseExpression(expr *ast.Expr) *Expression {
 		return parseBinaryExpression(e3)
 	}
 
-	e4, ok := (*expr).(*ast.ParenExpr)
+	e4, ok := (*expr).(*ast.UnaryExpr)
+	if ok {
+		return parseUnaryExpression(e4)
+	}
+
+	e5, ok := (*expr).(*ast.ParenExpr)
 	if ok {
-		return parseParenthesesExpression(e4)
+		return parseParenthesesExpression(e5)
 	}
 
-	e5, ok := (*expr).(*ast.CompositeLit)
+	e6, ok := (*expr).(*ast.CompositeLit)
 	if ok {
-		return parseArrayExpression(e5)
+		return parseArrayExpression(e6)
 	}
 
-	e6, ok := (*expr).(*ast.CallExpr)
+	e7, ok := (*expr).(*ast.CallExpr)
 	if ok {
-		return parseCallExpression(e6)
+		return parseCallExpression(e7)
 	}
 
-	e7, ok := (*expr).(*ast.IndexExpr)
+	e8, ok := (*expr).(*ast.IndexExpr)
 	if ok {
-		return parseIndexExpression(e7)
+		return parseIndexExpression(e8)
 	}
 
-	e8, ok := (*expr).(*ast.StarExpr)
+	e9, ok := (*expr).(*ast.StarExpr)
 	if ok {
-		return parseStarExpression(e8)
+		return parseStarExpression(e9)
 	}
 
-	e9, ok := (*expr).(*ast.SelectorExpr)
+	e10, ok := (*expr).(*ast.SelectorExpr)
 	if ok {
-		return parseSelectorExpression(e9)
+		return parseSelectorExpression(e10)
 	}
 
 	panic("parseExpression(): unknown expression type")

parse/parse.go

@@ -10,9 +10,9 @@ import (
 	"log"
 )
 
-func parseFile() {
+func parseFile(filename string) {
 	fset := token.NewFileSet()
-	node, err := parser.ParseFile(fset, "test.go", nil, parser.ParseComments)
+	node, err := parser.ParseFile(fset, filename, nil, parser.ParseComments)
 	if err != nil {
 		log.Fatal(err)
 	}

parse/parse_test.go

@@ -7,6 +7,6 @@ import "testing"
 
 func TestParseFile(t *testing.T) {
 	println()
-	parseFile()
+	parseFile("../detect/rule_single_point.go")
 	println()
 }

parse/statement.go

@@ -24,7 +24,11 @@ func (stmt *Statement) String() string {
 	if stmt.Name == ":=" {
 		// Input: res := 0
 		// Output: int res = 0
-		res = fmt.Sprintf("%s %s = %s", stmt.Args[1].NameType, stmt.Args[0].Name, stmt.Args[1])
+		nameType := stmt.Args[1].NameType
+		if nameType == "" {
+			nameType = "var"
+		}
+		res = fmt.Sprintf("%s %s = %s", nameType, stmt.Args[0].Name, stmt.Args[1])
 	} else if stmt.Name == "=" {
 		// Input: res = 5
 		// Output: res = 5

parse/statement_parse.go

@@ -35,7 +35,7 @@ func parseAssignStatement(stmt *ast.AssignStmt, level int) *Statement {
 
 	s := &Statement{
 		Level: level,
-		Name:  strings.ToLower(stmt.Tok.String()),
+		Name:  strings.ToLower(stmt.Tok.String()), // :=, =, ..
 		Args:  []*Expression{leftExpr, rightExpr},
 	}
 	return s