[ruby] Rework In Pattern Match Overtainting (#5227)

* [ruby] Rework In Pattern Match Overtainting
This change reworks the means of extracting the variables from an array pattern match by using an index access corresponding to the location we want to extract. e.g.
```ruby
case [type, location]
in [:value, result]
  puts "#{result}"
else
  puts "else"
end
```
Accesses `result` by `<tmp-0>[1]` (where `<tmp-0> = [type, location]`)

* Formatting

Author: David Baker Effendi

joern-cli/frontends/rubysrc2cpg/src/main/scala/io/joern/rubysrc2cpg/astcreation/AstForControlStructuresCreator.scala

@@ -11,6 +11,7 @@ import io.joern.rubysrc2cpg.astcreation.RubyIntermediateAst.{
   ForExpression,
   IfExpression,
   InClause,
+  IndexAccess,
   MatchVariable,
   MemberCall,
   NextExpression,
@@ -23,6 +24,7 @@ import io.joern.rubysrc2cpg.astcreation.RubyIntermediateAst.{
   SingleAssignment,
   SplattingRubyNode,
   StatementList,
+  StaticLiteral,
   UnaryExpression,
   Unknown,
   UnlessExpression,
@@ -299,18 +301,22 @@ trait AstForControlStructuresCreator(implicit withSchemaValidation: ValidationMo
               case x: ArrayPattern =>
                 val condition = expr.map(e => BinaryExpression(x, "===", e)(x.span)).getOrElse(inClause.pattern)
                 val body      = inClause.body
-                val variables = x.children.collect { case x: MatchVariable => x }
 
-                val conditionBody = if (variables.nonEmpty && expr.isDefined) {
-                  StatementList(variables.map { lhs =>
-                    SingleAssignment(lhs, "=", MatchVariable()(expr.get.span))(
-                      inClause.span
-                        .spanStart(s"${lhs.span.text} = ${RubyOperators.arrayPatternMatch}(${expr.get.text})")
+                val stmts = x.children.zipWithIndex.flatMap {
+                  case (lhs: MatchVariable, idx) if expr.isDefined =>
+                    val arrAccess = {
+                      val code    = s"${expr.get.text}[$idx]"
+                      val base    = expr.get.copy()(expr.get.span.spanStart(expr.get.text))
+                      val indices = StaticLiteral(idx.toString)(expr.get.span.spanStart(idx.toString)) :: Nil
+                      IndexAccess(base, indices)(lhs.span.spanStart(code))
+                    }
+                    val asgn = SingleAssignment(lhs, "=", arrAccess)(
+                      inClause.span.spanStart(s"${lhs.span.text} = ${expr.get.text}[$idx]")
                     )
-                  } :+ body)(body.span)
-                } else {
-                  body
-                }
+                    Option(asgn)
+                  case _ => None
+                } :+ body
+                val conditionBody = StatementList(stmts)(body.span)
 
                 (condition, conditionBody)
               case x =>

joern-cli/frontends/rubysrc2cpg/src/main/scala/io/joern/rubysrc2cpg/astcreation/AstForExpressionsCreator.scala

@@ -62,7 +62,6 @@ trait AstForExpressionsCreator(implicit withSchemaValidation: ValidationMode) {
     case node: ReturnExpression                 => astForReturnExpression(node)
     case node: AccessModifier                   => astForSimpleIdentifier(node.toSimpleIdentifier)
     case node: ArrayPattern                     => astForArrayPattern(node)
-    case node: MatchVariable                    => astForMatchVariable(node)
     case node: DummyNode                        => Ast(node.node)
     case node: Unknown                          => astForUnknown(node)
     case x =>
@@ -624,27 +623,14 @@ trait AstForExpressionsCreator(implicit withSchemaValidation: ValidationMode) {
     val callNode_ =
       callNode(node, code(node), Operators.arrayInitializer, Operators.arrayInitializer, DispatchTypes.STATIC_DISPATCH)
     val childrenAst = node.children.map {
-      case x: MatchVariable => astForExpression(SimpleIdentifier()(x.span))
-      case x                => astForExpression(x)
+      case x: MatchVariable if scope.lookupVariable(x.text).isEmpty => handleVariableOccurrence(x.toSimpleIdentifier)
+      case x: MatchVariable                                         => astForExpression(x.toSimpleIdentifier)
+      case x                                                        => astForExpression(x)
     }
 
     callAst(callNode_, childrenAst)
   }
 
-  protected def astForMatchVariable(node: MatchVariable): Ast = {
-    val nodeCode = shortenCode(s"${RubyOperators.arrayPatternMatch}(${node.span.text})")
-    val callNode_ = callNode(
-      node,
-      nodeCode,
-      RubyOperators.arrayPatternMatch,
-      RubyOperators.arrayPatternMatch,
-      DispatchTypes.STATIC_DISPATCH
-    )
-    val identAst = astForExpression(SimpleIdentifier()(node.span))
-
-    callAst(callNode_, identAst :: Nil)
-  }
-
   protected def astForMandatoryParameter(node: RubyExpression): Ast = handleVariableOccurrence(node)
 
   protected def astForSimpleCall(node: SimpleCall): Ast = {

joern-cli/frontends/rubysrc2cpg/src/main/scala/io/joern/rubysrc2cpg/passes/Defines.scala

@@ -39,7 +39,6 @@ object Defines {
     val hashInitializer   = "<operator>.hashInitializer"
     val association       = "<operator>.association"
     val splat             = "<operator>.splat"
-    val arrayPatternMatch = "<operator>.arrayPatternMatch"
     val regexpMatch       = "=~"
     val regexpNotMatch    = "!~"
   }

joern-cli/frontends/rubysrc2cpg/src/test/scala/io/joern/rubysrc2cpg/querying/CaseTests.scala

@@ -201,17 +201,17 @@ class CaseTests extends RubyCode2CpgFixture {
           case (lhs: Identifier) :: (rhs: Call) :: Nil =>
             lhs.name shouldBe "result"
 
-            rhs.methodFullName shouldBe RubyOperators.arrayPatternMatch
-            rhs.code shouldBe s"${RubyOperators.arrayPatternMatch}(<tmp-0>)"
+            rhs.methodFullName shouldBe Operators.indexAccess
+            rhs.code shouldBe s"<tmp-0>[1]"
           case xs => fail(s"Expected lhs and rhs, got [${xs.code.mkString(",")}]")
         }
 
         inside(notResultMatchAssignment.argument.l) {
           case (lhs: Identifier) :: (rhs: Call) :: Nil =>
             lhs.name shouldBe "notResult"
 
-            rhs.methodFullName shouldBe RubyOperators.arrayPatternMatch
-            rhs.code shouldBe s"${RubyOperators.arrayPatternMatch}(<tmp-0>)"
+            rhs.methodFullName shouldBe Operators.indexAccess
+            rhs.code shouldBe s"<tmp-0>[1]"
           case xs => fail(s"Expected lhs and rhs, got [${xs.code.mkString(",")}]")
         }
       case _ => fail(s"Expected two true branches")