feat: Added generation for Safe-DS stubs files

src/safeds_stubgen/api_analyzer/_mypy_helpers.py

@@ -76,7 +76,7 @@ def mypy_type_to_abstract_type(
     elif isinstance(mypy_type, mp_types.NoneType):
         return sds_types.NamedType(name="None", qname="builtins.None")
     elif isinstance(mypy_type, mp_types.LiteralType):
-        return sds_types.LiteralType(literal=mypy_type.value)
+        return sds_types.LiteralType(literals=[mypy_type.value])
     elif isinstance(mypy_type, mp_types.UnboundType):
         if mypy_type.name in {"list", "set"}:
             return {

src/safeds_stubgen/api_analyzer/_types.py

@@ -337,17 +337,17 @@ def __hash__(self) -> int:
 
 @dataclass(frozen=True)
 class LiteralType(AbstractType):
-    literal: str | int | float | bool
+    literals: list[str | int | float | bool]
 
     @classmethod
     def from_dict(cls, d: dict[str, Any]) -> LiteralType:
-        return LiteralType(d["literal"])
+        return LiteralType(d["literals"])
 
     def to_dict(self) -> dict[str, Any]:
-        return {"kind": self.__class__.__name__, "literal": self.literal}
+        return {"kind": self.__class__.__name__, "literals": [literal for literal in self.literals]}
 
     def __hash__(self) -> int:
-        return hash(frozenset([self.literal]))
+        return hash(frozenset(self.literals))
 
 
 @dataclass(frozen=True)

src/safeds_stubgen/stubs_generator/_generate_stubs.py

@@ -404,7 +404,7 @@
                         default_value = f"{param_default_value}"
                     param_value = f" = {default_value}"
                 elif parameter.is_optional and param_default_value is None:
                     param_value = " = null"
 
                 # Mypy assignes *args parameters the tuple type, which is not supported in Safe-DS. Therefor we
                 # overwrite it and set the type to a list.
@@ -569,8 +569,32 @@
                 return f"{name}<{', '.join(types)}>"
             return f"{name}<Any>"
         elif kind == "UnionType":
-            # Union items have to be unique. 'types' has to be a sorted list, since otherwise the snapshot tests would
-            # fail b/c element order in sets is non-deterministic.
+            # In Mypy LiteralTypes are getting seperated into unions of LiteralTypes,
+            # and we have to join them for the stubs.
+            literal_data = []
+            other_type_data = []
+            for type_information in type_data["types"]:
+                if type_information["kind"] == "LiteralType":
+                    literal_data.append(type_information)
+                else:
+                    other_type_data.append(type_information)
+
+            if len(literal_data) >= 2:
+                all_literals = [
+                    literal_type
+                    for literal in literal_data
+                    for literal_type in literal["literals"]
+                ]
+
+                # We overwrite the old types of the union with the joined literal types
+                type_data["types"] = other_type_data
+                type_data["types"].append({
+                    "kind": "LiteralType",
+                    "literals": all_literals,
+                })
+
+            # Union items have to be unique, therefore we use sets. But the types set has to be a sorted list, since
+            # otherwise the snapshot tests would fail b/c element order in sets is non-deterministic.
             types = list({self._create_type_string(type_) for type_ in type_data["types"]})
             types.sort()
 
@@ -596,10 +620,13 @@
             value_data = self._create_type_string(type_data["value_type"])
             return f"Map<{key_data}, {value_data}>"
         elif kind == "LiteralType":
-            literal_type = type_data["literal"]
-            if isinstance(literal_type, str):
-                literal_type = f'"{literal_type}"'
-            return f"literal<{literal_type}>"
+            types = []
+            for literal_type in type_data["literals"]:
+                if isinstance(literal_type, str):
+                    types.append(f'"{literal_type}"')
+                else:
+                    types.append(f'{literal_type}')
+            return f"literal<{', '.join(types)}>"
 
         raise ValueError(f"Unexpected type: {kind}")  # pragma: no cover
 

tests/data/various_modules_package/attribute_module.py

@@ -54,6 +54,8 @@ def some_func() -> bool:
     finals: Final[str, int] = "Value"
     final_union: Final[str | int] = "Value"
     literal: Literal["Some String"]
+    multiple_literals: Literal["Literal_1", "Literal_2", 3, True]
+    mixed_literal_union: Literal["L1", 2] | int | Literal[4, False] | str
 
     multi_attr_1, _multi_attr_2_private = (123456, "I am a String")
     multi_attr_3 = _multi_attr_4_private = ["I am some", "kind of list"]

tests/safeds_stubgen/api_analyzer/__snapshots__/test__get_api.ambr

@@ -490,7 +490,59 @@
       'name': 'literal',
       'type': dict({
         'kind': 'LiteralType',
-        'literal': 'Some String',
+        'literals': list([
+          'Some String',
+        ]),
+      }),
+    }),
+    dict({
+      'docstring': dict({
+        'default_value': '',
+        'description': '',
+        'type': '',
+      }),
+      'id': 'various_modules_package/attribute_module/AttributesClassB/mixed_literal_union',
+      'is_public': True,
+      'is_static': True,
+      'name': 'mixed_literal_union',
+      'type': dict({
+        'kind': 'UnionType',
+        'types': list([
+          dict({
+            'kind': 'LiteralType',
+            'literals': list([
+              'L1',
+            ]),
+          }),
+          dict({
+            'kind': 'LiteralType',
+            'literals': list([
+              2,
+            ]),
+          }),
+          dict({
+            'kind': 'NamedType',
+            'name': 'int',
+            'qname': 'builtins.int',
+          }),
+          dict({
+            'kind': 'LiteralType',
+            'literals': list([
+              4,
+            ]),
+          }),
+          dict({
+            'kind': 'LiteralType',
+            'literals': list([
+              False,
+            ]),
+          }),
+          dict({
+            'kind': 'NamedType',
+            'name': 'str',
+            'qname': 'builtins.str',
+          }),
+        ]),
       }),
     }),
     dict({
@@ -594,6 +646,46 @@
         'qname': 'builtins.str',
       }),
     }),
+    dict({
+      'docstring': dict({
+        'default_value': '',
+        'description': '',
+        'type': '',
+      }),
+      'id': 'various_modules_package/attribute_module/AttributesClassB/multiple_literals',
+      'is_public': True,
+      'is_static': True,
+      'name': 'multiple_literals',
+      'type': dict({
+        'kind': 'UnionType',
+        'types': list([
+          dict({
+            'kind': 'LiteralType',
+            'literals': list([
+              'Literal_1',
+            ]),
+          }),
+          dict({
+            'kind': 'LiteralType',
+            'literals': list([
+              'Literal_2',
+            ]),
+          }),
+          dict({
+            'kind': 'LiteralType',
+            'literals': list([
+              3,
+            ]),
+          }),
+          dict({
+            'kind': 'LiteralType',
+            'literals': list([
+              True,
+            ]),
+          }),
+        ]),
+      }),
+    }),
     dict({
       'docstring': dict({
         'default_value': '',
@@ -2239,11 +2331,15 @@
               'types': list([
                 dict({
                   'kind': 'LiteralType',
-                  'literal': 1,
+                  'literals': list([
+                    1,
+                  ]),
                 }),
                 dict({
                   'kind': 'LiteralType',
-                  'literal': 2,
+                  'literals': list([
+                    2,
+                  ]),
                 }),
               ]),
             }),
@@ -2290,11 +2386,15 @@
               'types': list([
                 dict({
                   'kind': 'LiteralType',
-                  'literal': 1,
+                  'literals': list([
+                    1,
+                  ]),
                 }),
                 dict({
                   'kind': 'LiteralType',
-                  'literal': 2,
+                  'literals': list([
+                    2,
+                  ]),
                 }),
               ]),
             }),
@@ -3513,7 +3613,9 @@
       'name': 'literal',
       'type': dict({
         'kind': 'LiteralType',
-        'literal': 'Some String',
+        'literals': list([
+          'Some String',
+        ]),
       }),
     }),
     dict({
@@ -4626,7 +4728,9 @@
       'name': 'result_1',
       'type': dict({
         'kind': 'LiteralType',
-        'literal': 'Some String',
+        'literals': list([
+          'Some String',
+        ]),
       }),
     }),
   ])

tests/safeds_stubgen/api_analyzer/test_types.py

@@ -221,20 +221,20 @@ def test_set_type() -> None:
 
 
 def test_literal_type() -> None:
-    type_ = LiteralType("Literal_1")
+    type_ = LiteralType(["Literal_1", 2])
     type_dict = {
         "kind": "LiteralType",
-        "literal": "Literal_1",
+        "literals": ["Literal_1", 2],
     }
 
     assert AbstractType.from_dict(type_dict) == type_
     assert LiteralType.from_dict(type_dict) == type_
     assert type_.to_dict() == type_dict
 
-    assert LiteralType("a") == LiteralType("a")
-    assert hash(LiteralType("a")) == hash(LiteralType("a"))
-    assert LiteralType("a") != LiteralType("b")
-    assert hash(LiteralType("a")) != hash(LiteralType("b"))
+    assert LiteralType(["a"]) == LiteralType(["a"])
+    assert hash(LiteralType(["a"])) == hash(LiteralType(["a"]))
+    assert LiteralType(["a"]) != LiteralType(["b"])
+    assert hash(LiteralType(["a"])) != hash(LiteralType(["b"]))
 
 
 def test_final_type() -> None:

tests/safeds_stubgen/stubs_generator/__snapshots__/test_generate_stubs.ambr

@@ -115,6 +115,10 @@
   	@PythonName("final_union")
   	static attr finalUnion: union<Int, String>
   	static attr `literal`: literal<"Some String">
+  	@PythonName("multiple_literals")
+  	static attr multipleLiterals: literal<"Literal_1", "Literal_2", 3, True>
+  	@PythonName("mixed_literal_union")
+  	static attr mixedLiteralUnion: union<Int, String, literal<"L1", 2, 4, False>>
   	@PythonName("multi_attr_1")
   	static attr multiAttr1: Int
   	@PythonName("multi_attr_3")