cyclomatic: Update cyclomatic complexity tool to handle SDKv1 roles

Author: abeaumont

cyclomatic.go

@@ -14,9 +14,12 @@ import (
 
 // This implementation uses PMD implementation as reference and uses the method of
 // counting one + one of the following UAST Roles if present on any children:
-// If | SwitchCase |  For[Each] | [Do]While | TryCatch | Continue | OpBoolean* | Goto
+// * Statement, If | Case | For | While | DoWhile | Continue
+// * Try, Catch
+// * Operator, Boolean
+// * Goto
 // Important: since some languages allow for code defined
-// outside function definitions, this won't check that the Node has the role FunctionDeclarationRole
+// outside function definitions, this won't check that the Node has the roles Function, Declaration
 // so the user should check that if the intended use is calculating the complexity of a function/method.
 // If the children contain more than one function definitions, the value will not be averaged between
 // the total number of function declarations but given as a total.
@@ -62,17 +65,20 @@ func cyclomaticComplexity(n *uast.Node) int {
 			break
 		}
 		n := p.Node()
+		roles := make(map[uast.Role]bool)
 		for _, r := range n.Roles {
-			if addsComplexity(r) {
-				complexity++
-			}
+			roles[r] = true
+		}
+		if addsComplexity(roles) {
+			complexity++
 		}
 	}
 	return complexity
 }
 
-func addsComplexity(r uast.Role) bool {
-	return r == uast.If || r == uast.SwitchCase || r == uast.For || r == uast.ForEach ||
-		r == uast.DoWhile || r == uast.While || r == uast.TryCatch || r == uast.Continue ||
-		r == uast.OpBooleanAnd || r == uast.OpBooleanOr || r == uast.OpBooleanXor
+func addsComplexity(roles map[uast.Role]bool) bool {
+	return roles[uast.Statement] && (roles[uast.If] || roles[uast.Case] || roles[uast.For] || roles[uast.While] || roles[uast.DoWhile] || roles[uast.Continue]) ||
+		roles[uast.Try] && roles[uast.Catch] ||
+		roles[uast.Operator] && roles[uast.Boolean] ||
+		roles[uast.Goto]
 }

cyclomatic_test.go

@@ -13,19 +13,19 @@ func TestCyclomaticComplexity(t *testing.T) {
 		Children: []*uast.Node{
 			{InternalType: "root"}, // 1 (initial)
 			// Prefix is the default so it doesnt need any role
-			{InternalType: "if1", Roles: []uast.Role{uast.If}, Children: []*uast.Node{ // 2 (If)
-				{InternalType: "if1else1", Roles: []uast.Role{uast.IfElse}, Children: []*uast.Node{ // 0
-					{InternalType: "if1else1foreach", Roles: []uast.Role{uast.ForEach}, Children: []*uast.Node{ // 3 (ForEach)
-						{InternalType: "foreach_child1"},                                             // 0
-						{InternalType: "foreach_child2_continue", Roles: []uast.Role{uast.Continue}}, // 4 (Continue)
+			{InternalType: "if1", Roles: []uast.Role{uast.Statement, uast.If}, Children: []*uast.Node{ // 2 (If, Statement)
+				{InternalType: "if1else1", Roles: []uast.Role{uast.If, uast.Then}, Children: []*uast.Node{ // 0
+					{InternalType: "if1else1foreach", Roles: []uast.Role{uast.Statement, uast.For, uast.Iterator}, Children: []*uast.Node{ // 3 (For, Statement)
+						{InternalType: "foreach_child1"},                                                             // 0
+						{InternalType: "foreach_child2_continue", Roles: []uast.Role{uast.Statement, uast.Continue}}, // 4 (Statement, Continue)
 					}},
-					{InternalType: "if1else1if", Roles: []uast.Role{uast.If}, Children: []*uast.Node{ // 5 (If)
-						{InternalType: "elseif_child1"},                                // 0
-						{InternalType: "opAnd", Roles: []uast.Role{uast.OpBooleanAnd}}, // 6 (OpBooleanAnd)
-						{InternalType: "elseif_child2"},                                // 0
+					{InternalType: "if1else1if", Roles: []uast.Role{uast.Statement, uast.If}, Children: []*uast.Node{ // 5 (Statement, If)
+						{InternalType: "elseif_child1"},                                                    // 0
+						{InternalType: "opAnd", Roles: []uast.Role{uast.Operator, uast.Boolean, uast.And}}, // 6 (Operator, Boolean)
+						{InternalType: "elseif_child2"},                                                    // 0
 					}},
 				}},
-				{InternalType: "break", Roles: []uast.Role{uast.Break}},
+				{InternalType: "break", Roles: []uast.Role{uast.Statement, uast.Break}},
 			},
 			}}}
 	require.Equal(cyclomaticComplexity(n), 6)