Supporting posonlyargs in Python

cpg-language-python/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/python/PythonLanguage.kt

@@ -31,6 +31,7 @@ import de.fraunhofer.aisec.cpg.frontends.Language
 import de.fraunhofer.aisec.cpg.frontends.of
 import de.fraunhofer.aisec.cpg.graph.HasOverloadedOperation
 import de.fraunhofer.aisec.cpg.graph.autoType
+import de.fraunhofer.aisec.cpg.graph.declarations.ParameterDeclaration
 import de.fraunhofer.aisec.cpg.graph.scopes.Symbol
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.BinaryOperator
 import de.fraunhofer.aisec.cpg.graph.statements.expressions.UnaryOperator
@@ -159,4 +160,20 @@ class PythonLanguage :
         // The rest behaves like other languages
         return super.propagateTypeOfBinaryOperation(operation)
     }
+
+    companion object {
+        /**
+         * This is a "modifier" to differentiate parameters in functions that are "positional" only.
+         * This information will be stored in [ParameterDeclaration.modifiers] so that we can use is
+         * later in call resolving.
+         */
+        const val MODIFIER_POSITIONAL_ONLY_ARGUMENT = "posonlyarg"
+
+        /**
+         * This is a "modifier" to differentiate parameters in functions that are "keyword" only.
+         * This information will be stored in [ParameterDeclaration.modifiers] so that we can use is
+         * later in call resolving.
+         */
+        const val MODIFIER_KEYWORD_ONLY_ARGUMENT = "kwonlyarg"
+    }
 }

cpg-language-python/src/main/kotlin/de/fraunhofer/aisec/cpg/frontends/python/StatementHandler.kt

@@ -25,6 +25,7 @@
  */
 package de.fraunhofer.aisec.cpg.frontends.python
 
+import de.fraunhofer.aisec.cpg.frontends.python.PythonLanguage.Companion.MODIFIER_POSITIONAL_ONLY_ARGUMENT
 import de.fraunhofer.aisec.cpg.graph.*
 import de.fraunhofer.aisec.cpg.graph.Annotation
 import de.fraunhofer.aisec.cpg.graph.declarations.*
@@ -38,6 +39,7 @@ import de.fraunhofer.aisec.cpg.graph.types.FunctionType
 
 class StatementHandler(frontend: PythonLanguageFrontend) :
     PythonHandler<Statement, Python.ASTBASEstmt>(::ProblemExpression, frontend) {
+
     override fun handleNode(node: Python.ASTBASEstmt): Statement {
         return when (node) {
             is Python.ASTClassDef -> handleClassDef(node)
@@ -237,7 +239,11 @@ class StatementHandler(frontend: PythonLanguageFrontend) :
 
         frontend.scopeManager.enterScope(cls)
 
-        stmt.keywords.map { TODO() }
+        stmt.keywords.forEach {
+            frontend.currentTU?.addDeclaration(
+                newProblemDeclaration("could not parse keyword $it in class")
+            )
+        }
 
         for (s in stmt.body) {
             when (s) {
@@ -382,20 +388,16 @@ class StatementHandler(frontend: PythonLanguageFrontend) :
         result: FunctionDeclaration,
         recordDeclaration: RecordDeclaration?
     ) {
-        // Handle arguments
-        if (args.posonlyargs.isNotEmpty()) {
-            val problem =
-                newProblemDeclaration(
-                    "`posonlyargs` are not yet supported",
-                    problemType = ProblemNode.ProblemType.TRANSLATION,
-                    rawNode = args
-                )
-            frontend.scopeManager.addDeclaration(problem)
-        }
+        // We can merge posonlyargs and args because both are positional arguments. We do not
+        // enforce that posonlyargs can ONLY be used in a positional style, whereas args can be used
+        // both in positional as well as keyword style.
+        var positionalArguments = args.posonlyargs + args.args
 
+        // Handle arguments
         if (recordDeclaration != null) {
             // first argument is the `receiver`
-            if (args.args.isEmpty()) {
+            val recvPythonNode = positionalArguments.firstOrNull()
+            if (recvPythonNode == null) {
                 val problem =
                     newProblemDeclaration(
                         "Expected a receiver",
@@ -404,7 +406,6 @@ class StatementHandler(frontend: PythonLanguageFrontend) :
                     )
                 frontend.scopeManager.addDeclaration(problem)
             } else {
-                val recvPythonNode = args.args.first()
                 val tpe = recordDeclaration.toType()
                 val recvNode =
                     newVariableDeclaration(
@@ -424,12 +425,12 @@ class StatementHandler(frontend: PythonLanguageFrontend) :
 
         if (recordDeclaration != null) {
             // first argument is the receiver
-            for (arg in args.args.subList(1, args.args.size)) {
-                handleArgument(arg)
+            for (arg in positionalArguments.subList(1, positionalArguments.size)) {
+                handleArgument(arg, arg in args.posonlyargs)
             }
         } else {
-            for (arg in args.args) {
-                handleArgument(arg)
+            for (arg in positionalArguments) {
+                handleArgument(arg, arg in args.posonlyargs)
             }
         }
 
@@ -554,9 +555,12 @@ class StatementHandler(frontend: PythonLanguageFrontend) :
         return result
     }
 
-    internal fun handleArgument(node: Python.ASTarg) {
+    internal fun handleArgument(node: Python.ASTarg, isPosOnly: Boolean = false) {
         val type = frontend.typeOf(node.annotation)
         val arg = newParameterDeclaration(name = node.arg, type = type, rawNode = node)
+        if (isPosOnly) {
+            arg.modifiers += MODIFIER_POSITIONAL_ONLY_ARGUMENT
+        }
 
         frontend.scopeManager.addDeclaration(arg)
     }

cpg-language-python/src/test/kotlin/de/fraunhofer/aisec/cpg/frontends/python/StatementHandlerTest.kt

@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2024, Fraunhofer AISEC. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ *                    $$$$$$\  $$$$$$$\   $$$$$$\
+ *                   $$  __$$\ $$  __$$\ $$  __$$\
+ *                   $$ /  \__|$$ |  $$ |$$ /  \__|
+ *                   $$ |      $$$$$$$  |$$ |$$$$\
+ *                   $$ |      $$  ____/ $$ |\_$$ |
+ *                   $$ |  $$\ $$ |      $$ |  $$ |
+ *                   \$$$$$   |$$ |      \$$$$$   |
+ *                    \______/ \__|       \______/
+ *
+ */
+package de.fraunhofer.aisec.cpg.frontends.python
+
+import de.fraunhofer.aisec.cpg.graph.*
+import de.fraunhofer.aisec.cpg.graph.edge.Properties
+import de.fraunhofer.aisec.cpg.test.analyze
+import java.nio.file.Path
+import kotlin.test.Test
+import kotlin.test.assertContains
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+
+class StatementHandlerTest {
+
+    @Test
+    fun testPosOnlyArguments() {
+        val topLevel = Path.of("src", "test", "resources", "python")
+        val result =
+            analyze(
+                listOf(
+                    topLevel.resolve("arguments.py").toFile(),
+                ),
+                topLevel,
+                true
+            ) {
+                it.registerLanguage<PythonLanguage>()
+            }
+        assertNotNull(result)
+
+        var myClass = result.records["MyClass"]
+        assertNotNull(myClass)
+
+        var func = result.functions["pos_only_and_args"]
+        assertNotNull(func)
+
+        val list = mapOf("a" to true, "b" to true, "c" to false)
+        list.keys.forEachIndexed { idx, name ->
+            var param = func.parameterEdges.firstOrNull { it.end.name.localName == name }
+            assertNotNull(param, "$name should not be empty")
+            if (list[name] == true) {
+                assertContains(
+                    param.end.modifiers,
+                    PythonLanguage.MODIFIER_POSITIONAL_ONLY_ARGUMENT
+                )
+            }
+            assertEquals(idx, param.getProperty(Properties.INDEX))
+        }
+    }
+}

cpg-language-python/src/test/resources/python/arguments.py

@@ -0,0 +1,7 @@
+def pos_only_and_args(a, b, /, c):
+    pass
+
+
+class MyClass:
+    def my_method(self, d, e):
+        pass