[CSharp] : Increase robustness - Block AST

joern-cli/frontends/csharpsrc2cpg/src/main/scala/io/joern/csharpsrc2cpg/astcreation/AstForStatementsCreator.scala

@@ -9,7 +9,7 @@ import io.shiftleft.codepropertygraph.generated.nodes.{NewFieldIdentifier, NewId
 import io.shiftleft.codepropertygraph.generated.{ControlStructureTypes, DispatchTypes, ModifierTypes, Operators}
 
 import scala.::
-import scala.util.Try
+import scala.util.{Try, Success, Failure}
 
 trait AstForStatementsCreator(implicit withSchemaValidation: ValidationMode) { this: AstCreator =>
 
@@ -362,11 +362,13 @@ trait AstForStatementsCreator(implicit withSchemaValidation: ValidationMode) { t
     * Thus, this is lowered as a try-finally, with finally making a call to `Dispose` on the declared variable.
     */
   private def astForUsingStatement(usingStmt: DotNetNodeInfo): Seq[Ast] = {
-    val tryNode     = controlStructureNode(usingStmt, ControlStructureTypes.TRY, code(usingStmt))
+    val tryNode = controlStructureNode(usingStmt, ControlStructureTypes.TRY, code(usingStmt))
+    val declAst = Try(createDotNetNodeInfo(usingStmt.json(ParserKeys.Declaration))) match {
+      case Success(declNodevalue) => astForNode(declNodevalue)
+      case _                      => Seq.empty[Ast]
+    }
     val tryNodeInfo = createDotNetNodeInfo(usingStmt.json(ParserKeys.Statement))
     val tryAst      = astForBlock(tryNodeInfo, Option("try"))
-    val declNode    = createDotNetNodeInfo(usingStmt.json(ParserKeys.Declaration))
-    val declAst     = astForNode(declNode)
 
     val finallyAst = declAst.flatMap(_.nodes).collectFirst { case x: NewIdentifier => x.copy }.map { id =>
       val callCode = s"${id.name}.Dispose()"

joern-cli/frontends/csharpsrc2cpg/src/test/scala/io/joern/csharpsrc2cpg/querying/ast/ControlStructureTests.scala

@@ -173,4 +173,37 @@ class ControlStructureTests extends CSharpCode2CpgFixture {
 
   }
 
+  "having using statement" should {
+    val cpg = code("""
+        |namespace other
+        |{
+        |    public class General
+        |    {
+        |        public static void Call(string name)
+        |        {
+        |            using (SqlConnection connection = new SqlConnection(name))
+        |            {
+        |                try
+        |                {
+        |                    connection.Open();
+        |                }
+        |                catch (Exception ex)
+        |                {
+        |                    Console.WriteLine(ex.Message);
+        |                    connection.Close();
+        |                }
+        |            }
+        |        }
+        |    }
+        |}
+        |""".stripMargin)
+
+    "resolve methodFullName" in {
+      inside(cpg.call.name("Open").methodFullName.l) {
+        case x :: Nil => x shouldBe "SqlConnection.Open:<unresolvedSignature>"
+        case _        => fail("Unexpected call node structure")
+      }
+    }
+  }
+
 }