upgrade deps + generated code (#1808)

Author: bbrehm

Diff for: build.sbt

@@ -1,7 +1,7 @@
 name := "codepropertygraph"
 
 // parsed by project/Versions.scala, updated by updateDependencies.sh
-val flatgraphVersion = "0.1.7"
+val flatgraphVersion = "0.1.9"
 
 inThisBuild(
   List(

Diff for: codepropertygraph/src/test/resources/cpg.fg

@@ -40,12 +40,21 @@ final class TraversalAnnotationBase[NodeType <: nodes.AnnotationBase](val traver
 
   /** Traverse to nodes where fullName matches one of the elements in `values` exactly.
     */
-  def fullNameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) fullNameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.fullName) }
+  def fullNameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return fullNameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 22, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.fullName) }
     }
+  }
 
   /** Traverse to nodes where fullName does not match the regular expression `value`.
     */
@@ -99,12 +108,21 @@ final class TraversalAnnotationBase[NodeType <: nodes.AnnotationBase](val traver
 
   /** Traverse to nodes where name matches one of the elements in `values` exactly.
     */
-  def nameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) nameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.name) }
+  def nameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return nameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 40, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.name) }
     }
+  }
 
   /** Traverse to nodes where name does not match the regular expression `value`.
     */

Diff for: domainClasses/src/main/generated/io/shiftleft/codepropertygraph/generated/traversals/TraversalAnnotationBase.scala

@@ -40,12 +40,21 @@ final class TraversalAnnotationliteralBase[NodeType <: nodes.AnnotationLiteralBa
 
   /** Traverse to nodes where name matches one of the elements in `values` exactly.
     */
-  def nameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) nameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.name) }
+  def nameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return nameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 40, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.name) }
     }
+  }
 
   /** Traverse to nodes where name does not match the regular expression `value`.
     */

Diff for: domainClasses/src/main/generated/io/shiftleft/codepropertygraph/generated/traversals/TraversalAnnotationliteralBase.scala

@@ -39,12 +39,21 @@ final class TraversalAstnodeBase[NodeType <: nodes.AstNodeBase](val traversal: I
 
   /** Traverse to nodes where code matches one of the elements in `values` exactly.
     */
-  def codeExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) codeExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.code) }
+  def codeExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return codeExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 10, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.code) }
     }
+  }
 
   /** Traverse to nodes where code does not match the regular expression `value`.
     */

Diff for: domainClasses/src/main/generated/io/shiftleft/codepropertygraph/generated/traversals/TraversalAstnodeBase.scala

@@ -39,12 +39,21 @@ final class TraversalBindingBase[NodeType <: nodes.BindingBase](val traversal: I
 
   /** Traverse to nodes where methodFullName matches one of the elements in `values` exactly.
     */
-  def methodFullNameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) methodFullNameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.methodFullName) }
+  def methodFullNameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return methodFullNameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 37, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.methodFullName) }
     }
+  }
 
   /** Traverse to nodes where methodFullName does not match the regular expression `value`.
     */
@@ -98,12 +107,21 @@ final class TraversalBindingBase[NodeType <: nodes.BindingBase](val traversal: I
 
   /** Traverse to nodes where name matches one of the elements in `values` exactly.
     */
-  def nameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) nameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.name) }
+  def nameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return nameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 40, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.name) }
     }
+  }
 
   /** Traverse to nodes where name does not match the regular expression `value`.
     */
@@ -157,12 +175,21 @@ final class TraversalBindingBase[NodeType <: nodes.BindingBase](val traversal: I
 
   /** Traverse to nodes where signature matches one of the elements in `values` exactly.
     */
-  def signatureExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) signatureExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.signature) }
+  def signatureExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return signatureExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 50, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.signature) }
     }
+  }
 
   /** Traverse to nodes where signature does not match the regular expression `value`.
     */

Diff for: domainClasses/src/main/generated/io/shiftleft/codepropertygraph/generated/traversals/TraversalBindingBase.scala

@@ -47,12 +47,21 @@ final class TraversalBlockBase[NodeType <: nodes.BlockBase](val traversal: Itera
 
   /** Traverse to nodes where typeFullName matches one of the elements in `values` exactly.
     */
-  def typeFullNameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) typeFullNameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.typeFullName) }
+  def typeFullNameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return typeFullNameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 53, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.typeFullName) }
     }
+  }
 
   /** Traverse to nodes where typeFullName does not match the regular expression `value`.
     */

Diff for: domainClasses/src/main/generated/io/shiftleft/codepropertygraph/generated/traversals/TraversalBlockBase.scala

@@ -39,12 +39,21 @@ final class TraversalCallBase[NodeType <: nodes.CallBase](val traversal: Iterato
 
   /** Traverse to nodes where dispatchType matches one of the elements in `values` exactly.
     */
-  def dispatchTypeExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) dispatchTypeExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.dispatchType) }
+  def dispatchTypeExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return dispatchTypeExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 17, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.dispatchType) }
     }
+  }
 
   /** Traverse to nodes where dispatchType does not match the regular expression `value`.
     */
@@ -102,12 +111,21 @@ final class TraversalCallBase[NodeType <: nodes.CallBase](val traversal: Iterato
 
   /** Traverse to nodes where methodFullName matches one of the elements in `values` exactly.
     */
-  def methodFullNameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) methodFullNameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.methodFullName) }
+  def methodFullNameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return methodFullNameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 37, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.methodFullName) }
     }
+  }
 
   /** Traverse to nodes where methodFullName does not match the regular expression `value`.
     */
@@ -165,12 +183,21 @@ final class TraversalCallBase[NodeType <: nodes.CallBase](val traversal: Iterato
 
   /** Traverse to nodes where typeFullName matches one of the elements in `values` exactly.
     */
-  def typeFullNameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) typeFullNameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.typeFullName) }
+  def typeFullNameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return typeFullNameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 53, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.typeFullName) }
     }
+  }
 
   /** Traverse to nodes where typeFullName does not match the regular expression `value`.
     */

Diff for: domainClasses/src/main/generated/io/shiftleft/codepropertygraph/generated/traversals/TraversalCallBase.scala

@@ -39,12 +39,21 @@ final class TraversalCallreprBase[NodeType <: nodes.CallReprBase](val traversal:
 
   /** Traverse to nodes where name matches one of the elements in `values` exactly.
     */
-  def nameExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) nameExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.name) }
+  def nameExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return nameExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 40, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.name) }
     }
+  }
 
   /** Traverse to nodes where name does not match the regular expression `value`.
     */
@@ -98,12 +107,21 @@ final class TraversalCallreprBase[NodeType <: nodes.CallReprBase](val traversal:
 
   /** Traverse to nodes where signature matches one of the elements in `values` exactly.
     */
-  def signatureExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) signatureExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.signature) }
+  def signatureExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return signatureExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 50, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.signature) }
     }
+  }
 
   /** Traverse to nodes where signature does not match the regular expression `value`.
     */

Diff for: domainClasses/src/main/generated/io/shiftleft/codepropertygraph/generated/traversals/TraversalCallreprBase.scala

@@ -186,12 +186,21 @@ final class TraversalClosurebindingBase[NodeType <: nodes.ClosureBindingBase](va
 
   /** Traverse to nodes where evaluationStrategy matches one of the elements in `values` exactly.
     */
-  def evaluationStrategyExact(values: String*): Iterator[NodeType] =
-    if (values.length == 1) evaluationStrategyExact(values.head)
-    else {
-      val valueSet = values.toSet
-      traversal.filter { item => valueSet.contains(item.evaluationStrategy) }
+  def evaluationStrategyExact(values: String*): Iterator[NodeType] = {
+    if (values.length == 1) return evaluationStrategyExact(values.head)
+    traversal match {
+      case init: flatgraph.misc.InitNodeIterator[flatgraph.GNode @unchecked] if init.isVirgin && init.hasNext =>
+        val someNode = init.next
+        values.iterator.flatMap { value =>
+          flatgraph.Accessors
+            .getWithInverseIndex(someNode.graph, someNode.nodeKind, 19, value)
+            .asInstanceOf[Iterator[NodeType]]
+        }
+      case _ =>
+        val valueSet = values.toSet
+        traversal.filter { item => valueSet.contains(item.evaluationStrategy) }
     }
+  }
 
   /** Traverse to nodes where evaluationStrategy does not match the regular expression `value`.
     */