fix failing code

joern-cli/frontends/kotlin2cpg/src/main/scala/io/joern/kotlin2cpg/Main.scala

@@ -56,6 +56,10 @@ final case class Config(
   def withKeepTypeArguments(value: Boolean): Config = {
     copy(keepTypeArguments = value).withInheritedFields(this)
   }
+
+  def withResolveTypes(value: Boolean): Config = {
+    copy(resolveTypes = value).withInheritedFields(this)
+  }
 }
 
 private object Frontend {

joern-cli/frontends/rubysrc2cpg/src/main/scala/io/joern/rubysrc2cpg/RubySrc2Cpg.scala

@@ -6,7 +6,7 @@ import io.joern.rubysrc2cpg.astcreation.RubyIntermediateAst.StatementList
 import io.joern.rubysrc2cpg.datastructures.RubyProgramSummary
 import io.joern.rubysrc2cpg.deprecated.parser.DeprecatedRubyParser
 import io.joern.rubysrc2cpg.deprecated.parser.DeprecatedRubyParser.*
-import io.joern.rubysrc2cpg.parser.*
+import io.joern.rubysrc2cpg.parser.{RubyJsonParser, RubyJsonToNodeCreator, RubyAstGenRunner}
 import io.joern.rubysrc2cpg.passes.{
   AstCreationPass,
   ConfigFileCreationPass,
@@ -19,6 +19,7 @@ import io.joern.x2cpg.frontendspecific.rubysrc2cpg.*
 import io.joern.x2cpg.passes.base.AstLinkerPass
 import io.joern.x2cpg.passes.callgraph.NaiveCallLinker
 import io.joern.x2cpg.passes.frontend.{MetaDataPass, TypeNodePass, XTypeRecoveryConfig}
+import io.joern.x2cpg.utils.ExternalCommand.ExternalCommandResult
 import io.joern.x2cpg.utils.{ConcurrentTaskUtil, ExternalCommand}
 import io.joern.x2cpg.{SourceFiles, X2CpgFrontend}
 import io.shiftleft.codepropertygraph.generated.{Cpg, Languages}
@@ -49,11 +50,13 @@ class RubySrc2Cpg extends X2CpgFrontend[Config] {
   }
 
   private def newCreateCpgAction(cpg: Cpg, config: Config): Unit = {
-    Using.resource(
-      new parser.ResourceManagedParser(config.antlrCacheMemLimit, config.antlrDebug, config.antlrProfiling)
-    ) { parser =>
+    File.usingTemporaryDirectory("rubysrc2cpgOut") { tmpDir =>
+      val astGenResult = RubyAstGenRunner(config).execute(tmpDir)
+
       val astCreators = ConcurrentTaskUtil
-        .runUsingThreadPool(RubySrc2Cpg.generateParserTasks(parser, config, cpg.metaData.root.headOption))
+        .runUsingThreadPool(
+          RubySrc2Cpg.processAstGenRunnerResults(astGenResult.parsedFiles, config, cpg.metaData.root.headOption)
+        )
         .flatMap {
           case Failure(exception)  => logger.warn(s"Unable to parse Ruby file, skipping -", exception); None
           case Success(astCreator) => Option(astCreator)
@@ -135,18 +138,18 @@ class RubySrc2Cpg extends X2CpgFrontend[Config] {
 
   private def downloadDependency(inputPath: String, tempPath: String): Unit = {
     if (Files.isRegularFile(Paths.get(s"${inputPath}${java.io.File.separator}Gemfile"))) {
-      ExternalCommand.run(s"bundle config set --local path ${tempPath}", inputPath) match {
-        case Success(configOutput) =>
-          logger.info(s"Gem config successfully done: $configOutput")
-        case Failure(exception) =>
-          logger.error(s"Error while configuring Gem Path: ${exception.getMessage}")
+      ExternalCommand.run(Seq("bundle", "config", "set", "--local", "path", tempPath), inputPath) match {
+        case ExternalCommandResult(0, stdOut, _) =>
+          logger.info(s"Gem config successfully done")
+        case ExternalCommandResult(_, stdOut, _) =>
+          logger.error(s"Error while configuring Gem Path: ${stdOut.mkString(System.lineSeparator())}")
       }
-      val command = s"bundle install"
+      val command = Seq("bundle", "install")
       ExternalCommand.run(command, inputPath) match {
-        case Success(bundleOutput) =>
-          logger.info(s"Dependency installed successfully: $bundleOutput")
-        case Failure(exception) =>
-          logger.error(s"Error while downloading dependency: ${exception.getMessage}")
+        case ExternalCommandResult(0, stdOut, _) =>
+          logger.info(s"Dependency installed successfully")
+        case ExternalCommandResult(_, stdOut, _) =>
+          logger.error(s"Error while downloading dependency: ${stdOut.mkString(System.lineSeparator())}")
       }
     }
   }
@@ -177,37 +180,6 @@ object RubySrc2Cpg {
     }
   }
 
-  def generateParserTasks(
-    resourceManagedParser: parser.ResourceManagedParser,
-    config: Config,
-    projectRoot: Option[String]
-  ): Iterator[() => AstCreator] = {
-    SourceFiles
-      .determine(
-        config.inputPath,
-        RubySourceFileExtensions,
-        ignoredDefaultRegex = Option(config.defaultIgnoredFilesRegex),
-        ignoredFilesRegex = Option(config.ignoredFilesRegex),
-        ignoredFilesPath = Option(config.ignoredFiles)
-      )
-      .map { fileName => () =>
-        resourceManagedParser.parse(File(config.inputPath), fileName) match {
-          case Failure(exception) => throw exception
-          case Success(ctx) =>
-            val fileContent = (File(config.inputPath) / fileName).contentAsString
-            new AstCreator(
-              fileName,
-              ctx,
-              projectRoot,
-              enableFileContents = !config.disableFileContent,
-              fileContent = fileContent,
-              rootNode = Option(new RubyNodeCreator().visit(ctx).asInstanceOf[StatementList])
-            )(config.schemaValidation)
-        }
-      }
-      .iterator
-  }
-
   /** Parses the generated AST Gen files in parallel and produces AstCreators from each.
     */
   def processAstGenRunnerResults(

joern-cli/frontends/rubysrc2cpg/src/main/scala/io/joern/rubysrc2cpg/parser/AnltrAstPrinter.scala

@@ -0,0 +1,36 @@
+package io.joern.rubysrc2cpg.parser
+
+import org.antlr.v4.runtime.ParserRuleContext
+import org.antlr.v4.runtime.tree.TerminalNode
+
+/** General purpose ANTLR parse tree printer.
+  */
+object AnltrAstPrinter {
+  private val indentationIncrement = 1
+
+  private def print(level: Int, sb: StringBuilder, context: ParserRuleContext): StringBuilder = {
+    val indentation = " ".repeat(level)
+    val contextName = context.getClass.getSimpleName.stripSuffix("Context")
+    val nextLevel   = level + indentationIncrement
+    sb.append(s"$indentation$contextName\n")
+    Option(context.children).foreach(_.forEach {
+      case c: ParserRuleContext => print(nextLevel, sb, c)
+      case t: TerminalNode      => print(nextLevel, sb, t)
+    })
+    sb
+  }
+
+  private def print(level: Int, sb: StringBuilder, terminal: TerminalNode): StringBuilder = {
+    val indentation = " ".repeat(level)
+    sb.append(s"$indentation${terminal.getText}\n")
+    sb
+  }
+
+  /** Pretty-prints an entire `ParserRuleContext` together with its descendants.
+    * @param context
+    *   the context to pretty-print
+    * @return
+    *   an indented, multiline string representation
+    */
+  def print(context: ParserRuleContext): String = print(0, new StringBuilder, context).toString()
+}

joern-cli/frontends/rubysrc2cpg/src/test/scala/io/joern/rubysrc2cpg/testfixtures/RubyCode2CpgFixture.scala

@@ -1,5 +1,6 @@
 package io.joern.rubysrc2cpg.testfixtures
 
+import java.io.File
 import io.joern.dataflowengineoss.DefaultSemantics
 import io.joern.dataflowengineoss.language.Path
 import io.joern.dataflowengineoss.semanticsloader.{FlowSemantic, Semantics}
@@ -10,7 +11,7 @@ import io.joern.x2cpg.ValidationMode
 import io.joern.x2cpg.testfixtures.*
 import io.shiftleft.codepropertygraph.generated.Cpg
 import io.shiftleft.semanticcpg.language.{ICallResolver, NoResolve}
-import org.scalatest.Inside
+import org.scalatest.{Inside, Tag}
 
 import java.nio.file.Files
 import scala.jdk.CollectionConverters.*